C & C++ Multimedia Cyber Classroom

home *** CD-ROM | disk | FTP | other *** search

/ C & C++ Multimedia Cyber Classroom / C and C++ Multimedia Cyber Classroom (Prentice Hall) (1998).iso / cpphtp2 / cpphtp2.jar / chpt_02.gml < prev next >

Wrap

Text File | 1998-03-03 | 280KB | 6,854 lines

<html> <chapter> <section type=Popup name=Quotes title="Quotes"> <page> Let's all move one place on. Lewis Carroll </page> <page> The wheel is come full circle. William Shakespeare, King Lear </page> <page> Who can control his fate? William Shakespeare, Othello </page> <page> The used key is always bright. Benjamin Franklin </page> </section> <section type=Popup name=Answers title="Answers"> <page pagename="Answer 2.1"> Answer 2.1 a) Sequence, selection, and repetition. b) if/else. c) Counter-controlled or definite. d) Sentinel, signal, flag, or dummy. <foreign name="exercises" url="^Exercises::c:s0p0"> </page> <page pagename="Answer 2.2"> Answer 2.2 <pre> x = x + 1; x += 1; ++x; x++; </pre> <foreign name="exercises" url="^Exercises::c:s0p2"> </page> <page pagename="Answer 2.2"> Answer 2.3 <pre> a) z = x++ + y; b) if ( count > 10 ) cout << "Count is greater than 10" << endl; c) total -= --x; d) q %= divisor; e) q = q % divisor; </pre> <foreign name="exercises" url="^Exercises::c:s0p3"> </page> <page pagename="Answer 2.4"> Answer 2.4 <pre> a) int sum, x; b) x = 1; c) sum = 0; d) sum += x; or sum = sum + x; e) cout << "The sum is: " << sum << endl; </pre> <foreign name="exercises" url="^Exercises::c:s0p4"> </page> <page pagename="Answer 2.5"> Answer 2.5 <pre> 1 // Calculate the sum of the integers from 1 to 10 2 #include <iostream.h> 3 4 int main() 5 { 6 int sum, x; 7 x = 1; 8 sum = 0; 9 while ( x <= 10 ) { 10 sum += x; 11 ++x; </pre> <foreign name="exercises" url="^Exercises::c:s0p5"> </page> <page pagename="Answer 2.5"> <pre> 12 } </pre> <pre> 13 cout << "The sum is: " << sum << endl; 14 return 0; 15 } </pre> <foreign name="exercises" url="^Exercises::c:s0p5"> </page> <page pagename="Answer 2.6"> Answer 2.6 <pre> a) product = 25, x = 6; b) quotient = 0, x = 6; </pre> <foreign name="exercises" url="^Exercises::c:s0p6"> </page> <page pagename="Answer 2.7"> Answer 2.7 <pre> a) cin >> x; b) cin >> y; c) i = 1; d) power = 1; e) power *= x; or power = power * x; f) y++; g) if ( y <= x ) h) cout << power << endl; </pre> <foreign name="exercises" url="^Exercises::c:s0p7"> </page> <page pagename="Answer 2.8"> Answer 2.8 <pre> 1 // raise x to the y power 2 #include <iostream.h> 3 int main() 4 { 5 int x, y, i, power; 6 7 i = 1; 8 power = 1; 9 cin >> x; 10 cin >> y; 11 </pre> <foreign name="exercises" url="^Exercises::c:s0p8"> </page> <page pagename="Answer 2.8"> <pre> 12 while ( i <= y ) { </pre> <pre> 13 power *= x; 14 ++i; 15 } 16 17 cout << power << endl; 18 return 0; 19 } </pre> <foreign name="exercises" url="^Exercises::c:s0p8"> </page> <page pagename="Answer 2.9"> Answer 2.9 a) Error: Missing the closing right brace of the while body. Correction: Add closing right brace after the statement ++c;. b) Error: Used stream insertion instead of stream extraction. Correction: Change << to >>. c) Error: Semicolon after else results in a logic error. The second output statement will always be executed. Correction: Remove the semicolon after else. <foreign name="exercises" url="^Exercises::c:s0p9"> </page> <page pagename="Answer 2.10"> Answer 2.10 The value of the variable z is never changed in the while structure. Therefore, if the loop-continuation condition (z >= 0) is true, an infinite loop is created. To prevent the infinite loop, z must be decremented so that it eventually becomes less than 0. <foreign name="exercises" url="^Exercises::c:s0p10"> </page> <page pagename="Answer 2.11"> Answer 2.11 a) False. The default case is optional. If no default action is needed, then there is no need for a default case. b) False. The break statement is used to exit the switch structure. The break statement is not required when the default case is the last case. c) False. Both of the relational expressions must be true in order for the entire expression to be true when using the && operator. d) True. <foreign name="exercises" url="^Exercises::c:s0p11"> </page> <page pagename="Answer 2.12"> Answer 2.12 <pre> a) sum = 0; for ( count = 1; count <= 99; count += 2 sum += count; b) cout << setiosflags(ios::fixed | ios::showpoint | ios::left) << setprecision( 1 ) << setw( 15 ) << 333.546372 << setprecision( 2 ) << setw( 15 ) << 333.546372 << setprecision( 3 ) << setw( 15 ) << 333.546372 << endl; </pre> Output is: <pre> 333.5 333.55 333.546 </pre> <foreign name="exercises" url="^Exercises::c:s0p12"> </page> <page pagename="Answer 2.12"> <pre> c) cout << setiosflags( ios::fixed | ios::showpoint ) </pre> <pre> << setprecision( 2 ) << setw( 10 ) << pow( 2.5, 3 ) << endl; </pre> Output is: <pre> 15.63 d) x = 1; while ( x <= 20 ) { cout << x; if ( x % 5 == 0 ) cout << endl; else </pre> <foreign name="exercises" url="^Exercises::c:s0p12"> </page> <page pagename="Answer 2.12"> <pre> cout << '\ '; </pre> <pre> x++; } e) for ( x = 1; x <= 20; x++ ) { cout << x; if ( x % 5 == 0 ) cout << endl; else cout << '\ '; } </pre> or <foreign name="exercises" url="^Exercises::c:s0p12"> </page> <page pagename="Answer 2.12"> <pre> for ( x = 1; x <= 20; x++ ) </pre> <pre> if ( x % 5 == 0 ) cout << x << endl; else cout << x << '\ '; </pre> <foreign name="exercises" url="^Exercises::c:s0p12"> </page> <page pagename="Answer 2.13"> Answer 2.13 a) Error: The semicolon after the while header causes an infinite loop. Correction: Replace the semicolon by a { or remove both the ; and the }. b) Error: Using a floating-point number to control a for repetition structure. Correction: Use an integer, and perform the proper calculation in order to get the values you desire. <pre> for ( y = 1; y != 10; y++ ) cout << ( static_cast< float >( y ) / 10 ) << endl; </pre> c) Error: Missing break statement in the statements for the first case. Correction: Add a break statement at the end of the statements for the first case. Note that this is not necessarily an error if the programmer wants the <foreign name="exercises" url="^Exercises::c:s0p14"> </page> <page pagename="Answer 2.13"> statement of case 2: to execute every time the case 1: statement executes. d) Error: Improper relational operator used in the while repetition-continuation condition. Correction: Use <= rather than < or change 10 to 11. <foreign name="exercises" url="^Exercises::c:s0p14"> </page> <page pagename="Answer 2.14"> Answer 2.14 a) The semicolon at the end of the if should be removed. The closing double quote after the second endl should be placed after 65. b) The semicolon after the else should be removed. The closing double quote after the second endl should be placed after 65. c) Variable total should be initialized to 0. d) The W in while should be lowercase. The while's body should be enclosed in braces {}. e) The variable y should be decremented (i.e., --y;) not incremented ( ++y;). <foreign name="exercises" url="^Exercises::c:s0p16"> </page> <page pagename="Answer 2.24"> Answer 2.24 <hr> <pre> **** ++++++++ **** ++++++++ **** ++++++++ **** ++++++++ **** ++++++++ </pre> <hr> <foreign name="exercises" url="^Exercises::c:s0p35"> </page> <page pagename="Answer 2.26"> Answer 2.26 a) x = 9, y = 11 <hr> <pre> ***** $$$$$ </pre> <hr> x = 11, y = 9 <hr> <pre> $$$$$ </pre> <hr> <foreign name="exercises" url="^Exercises::c:s0p38"> </page> <page pagename="Answer 2.26"> b) x = 9, y = 11 <hr> <pre> ***** </pre> <hr> x = 11, y = 9 <hr> <pre> ##### $$$$$ </pre> <hr> <foreign name="exercises" url="^Exercises::c:s0p38"> </page> <page pagename="Answer 2.16 "> Answer 2.16 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_16.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p22"> </page> <page pagename="Answer 2.18 "> Answer 2.18 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_18.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p27"> </page> <page pagename="Answer 2.20 "> Answer 2.20 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_20.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p31"> </page> <page pagename="Answer 2.29 "> Answer 2.29 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_29.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p44"> </page> <page pagename="Answer 2.31 "> Answer 2.31 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_31.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p46"> </page> <page pagename="Answer 2.33 "> Answer 2.33 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_33.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p49"> </page> <page pagename="Answer 2.37 "> Answer 2.37 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_37.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p53"> </page> <page pagename="Answer 2.40 "> Answer 2.40 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_40.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p58"> </page> <page pagename="Answer 2.43 "> Answer 2.43 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_43.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p62"> </page> <page pagename="Answer 2.45 "> Answer 2.45 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_45.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p64"> </page> <page pagename="Answer 2.48 "> Answer 2.48 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_48.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p68"> </page> <page pagename="Answer 2.49 "> Answer 2.49 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_49.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p69"> </page> <page pagename="Answer 2.54 "> Answer 2.54 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_54.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p74"> </page> <page pagename="Answer 2.58 "> Answer 2.58 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_58.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p80"> </page> <page pagename="Answer 2.60 "> Answer 2.60 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_60.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p83"> </page> <page pagename="Answer 2.63 "> Answer 2.63 The solution to this exercise can be found on your Cyber Classroom CD. Copy the file cpphtp2/answers/P2_63.zip to your hard drive and unzip the program code. <foreign name="exercises" url="^Exercises::c:s0p86"> </page> </section> <section type=Body name=Default title="2 Control Structures"> <page> 2 Control Structures<hr> <a href="#s1p0">2.1<spacer width=20 height=1>Introduction</a> <a href="#s2p0">2.2<spacer width=20 height=1>Algorithms</a> <a href="#s3p0">2.3<spacer width=20 height=1>Pseudocode</a> <a href="#s4p0">2.4<spacer width=20 height=1>Control Structures</a> <a href="#s5p0">2.5<spacer width=20 height=1>The if Selection Structure</a> <a href="#s6p0">2.6<spacer width=20 height=1>The if/else Selection Structure</a> <a href="#s7p0">2.7<spacer width=20 height=1>The while Repetition Structure</a> <a href="#s8p0">2.8<spacer width=20 height=1>Formulating Algorithms: Case Study 1 (Counter- Controlled Repetition)</a> <foreign name="objectivesButton" url="^Objective::c:s0p0"> <foreign name="quotes" url="^Quotes::c:s0p0"> </page> <page> <a href="#s9p0">2.9<spacer width=20 height=1>Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel-Controlled Repetition)</a> <a href="#s10p0">2.10<spacer width=20 height=1>Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)</a> <a href="#s11p0">2.11<spacer width=20 height=1>Assignment Operators</a> <a href="#s12p0">2.12<spacer width=20 height=1>Increment and Decrement Operators</a> <a href="#s13p0">2.13<spacer width=20 height=1>Essentials of Counter-Controlled Repetition</a> <a href="#s14p0">2.14<spacer width=20 height=1>The for Repetition Structure</a> <a href="#s15p0">2.15<spacer width=20 height=1>Examples Using the for Structure</a> <a href="#s16p0">2.16<spacer width=20 height=1>The switch Multiple-Selection Structure</a> <foreign name="objectivesButton" url="^Objective::c:s0p0"> <foreign name="quotes" url="^Quotes::c:s0p0"> </page> <page> <a href="#s17p0">2.17<spacer width=20 height=1>The do/while Repetition Structure</a> <a href="#s18p0">2.18<spacer width=20 height=1>The break and continue Statements</a> <a href="#s19p0">2.19<spacer width=20 height=1>Logical Operators</a> <a href="#s20p0">2.20<spacer width=20 height=1>Confusing Equality (==) and Assignment (=) Operators</a> <a href="#s21p0">2.21<spacer width=20 height=1>Structured Programming Summary</a> <a href="#s22p0">2.22<spacer width=20 height=1>Thinking About Objects: Identifying the Objects in a Problem</a> <a href="#s23p0">2.23<spacer width=20 height=1>Elevator Laboratory Assignment 1</a> <a href="#s24p0">2.24<spacer width=20 height=1>Summary</a> <a href="^Terminology::c:s0p0">Terminology</a> <a href="^Illustration::c:s0p0">Figures</a> <foreign name="objectivesButton" url="^Objective::c:s0p0"> <foreign name="quotes" url="^Quotes::c:s0p0"> </page> </section> <section type=Body name=Default title="2.1 Introduction"> <page> 2.1 Introduction<hr> Before writing a program to solve a particular problem, it is essential to have a thorough understanding of the problem and a carefully planned approach to solving the problem. When writing a program, it is equally essential to understand the types of building blocks that are available and to employ proven program construction principles. In this chapter we discuss all of these issues in our presentation of the theory and principles of structured programming. The techniques that you will learn here are applicable to most high- level languages, including C++. When we begin our </page> <page> treatment of object-oriented programming in C++ in Chapter 6, we will see that the control structures we study here in Chapter 2 are helpful in building and manipulating objects. </page> </section> <section type=Body name=Default title="2.2 Algorithms"> <page> 2.2 Algorithms<hr> Any computing problem can be solved by executing a series of actions in a specific order. A procedure for solving a problem in terms of 1. the actions to be executed, and 2. the order in which these actions are to be executed is called an algorithm. The following example demonstrates that correctly specifying the order in which the actions are to be executed is important. <spacer width=16 height=1>Consider the "rise-and-shine algorithm" followed by one junior executive for getting out of bed and going to work: (1) Get out of bed, (2) take off pajamas, (3) take a </page> <page> shower, (4) get dressed, (5) eat breakfast, (6) carpool to work. <spacer width=16 height=1>This routine gets the executive to work well prepared to make critical decisions. Suppose, however, that the same steps are performed in a slightly different order: (1) Get out of bed, (2) take off pajamas, (3) get dressed, (4) take a shower, (5) eat breakfast, (6) carpool to work. <spacer width=16 height=1>In this case, our junior executive shows up for work soaking wet. Specifying the order in which statements are to be executed in a computer program is called program control. In this chapter, we investigate the program control capabilities of C++. </page> <page> Drag the appropriate term to its matching box so the resulting sentence defines the term algorithm. A <component type="drag" width=72 height=18 label="procedure" name="procedure"> for solving a problem in terms of the <component type="drag" width=56 height=18 label="actions" name="actions"> to be executed, and the <component type="drag" width=40 height=18 label="order" name="order"> in which these actions are to be executed. Any computer problem can be solved by a <component type="drop" width=48 height=18 name="procedure"> consisting of a series of <component type="drop" width=48 height=18 name="actions"> executed in <component type="drop" width=48 height=18 name="order">. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.3 Pseudocode"> <page> 2.3 Pseudocode<hr> Pseudocode is an artificial and informal language that helps programmers develop algorithms. The pseudocode we present here is particularly useful for developing algorithms that will be converted to structured C++ programs. Pseudocode is similar to everyday English; it is convenient and user-friendly although it is not an actual computer programming language. <spacer width=16 height=1>Pseudocode programs are not actually executed on computers. Rather, they help the programmer "think out" a program before attempting to write it in a </page> <page> programming language such as C++. In this chapter, we give several examples of how pseudocode may be used effectively in developing structured C++ programs. <spacer width=16 height=1>The style of pseudocode we present consists purely of characters, so programmers can conveniently type pseudocode programs using an editor program. The computer can display a fresh copy of a pseudocode program on demand. A carefully prepared pseudocode program may be converted easily to a corresponding C++ program. This is done in many cases simply by replacing pseudocode statements with their C++ equivalents. </page> <page> Pseudocode consists only of executable statements-- those that are executed when the program has been converted from pseudocode to C++ and is run. Declarations are not executable statements. For example, the declaration <pre> int i; </pre> simply tells the compiler the type of variable i and instructs the compiler to reserve space in memory for the variable. But this declaration does not cause any action--such as input, output, or a calculation--to occur when the program is executed. Some programmers choose to list variables and briefly </page> <page> mention the purpose of each at the beginning of a pseudocode program. </page> <page> From the items listed below, select the ones that are true about pseudocode. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Pseudocode is an artificial and informal language. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Some programmers use pseudocode as an aid in problem solving. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Pseudocode is not compiled."> Pseudocode compiles quickly. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Carefully prepared pseudocode can be easily converted to a C++ progam. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Pseudocode is not executed."> Pseudocode is one of the slowest executing languages. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.4 Control Structures"> <page> 2.4 Control Structures<hr> Normally, statements in a program are executed one after the other in the order in which they are written. This is called sequential execution. Various C++ statements we will soon discuss enable the programmer to specify that the next statement to be executed may be other than the next one in sequence. This is called transfer of control. <spacer width=16 height=1>During the 1960s, it became clear that the indiscriminate use of transfers of control was the root of much difficulty experienced by software development groups. The finger of blame was pointed at the goto </page> <page> statement that allows the programmer to specify a transfer of control to one of a very wide range of possible destinations in a program. The notion of so- called structured programming became almost synonymous with "goto elimination." <spacer width=16 height=1>The research of Bohm and Jacopini (<spacer width=20 height=1>Bohm, C. and G. Jacopini, "Flow Diagrams, Turing Machines, and Languages with Only Two Formation Rules," Communications of the ACM, Vol. 9, No. 5, May 1966, pp. 336-371.) had demonstrated that programs could be written without any goto statements. The challenge of the era became for programmers to shift their styles to "goto-less programming." It was not until the 1970s </page> <page> that programmers started taking structured programming seriously. The results have been impressive as software development groups have reported reduced development times, more frequent on- time delivery of systems, and more frequent within- budget completion of software projects. The key to these successes is that structured programs are clearer, easier to debug and modify, and more likely to be bug- free in the first place. <spacer width=16 height=1>Bohm and Jacopini's work demonstrated that all programs could be written in terms of only three control structures, namely the sequence structure, the selection structure, and the repetition structure. The sequence </page> <page> structure is built into C++. Unless directed otherwise, the computer executes C++ statements one after the other in the order in which they are written. The flowchart segment of <a href="^Illustration::c:s0p3"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.1</a> illustrates a typical sequence structure in which two calculations are performed in order. <spacer width=16 height=1>A flowchart is a graphical representation of an algorithm or of a portion of an algorithm. Flowcharts are drawn using certain special-purpose symbols such as rectangles, diamonds, ovals, and small circles; these symbols are connected by arrows called flowlines. <spacer width=16 height=1>Like pseudocode, flowcharts are useful for developing and representing algorithms, although pseudocode is </page> <page> strongly preferred by most programmers. Flowcharts clearly show how control structures operate; that is all we use them for in this text. <spacer width=16 height=1>Consider the flowchart segment for the sequence structure in <a href="^Illustration::c:s0p3"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.1</a>. We use the rectangle symbol, also called the action symbol, to indicate any type of action including a calculation or an input/output operation. The flowlines in the figure indicate the order in which the actions are to be performed--first, grade is to be added to total then 1 is to be added to counter. C++ allows us to have as many actions as we want in a sequence structure. As we will soon see, anywhere a single action </page> <page> may be placed, we may place several actions in sequence. <spacer width=16 height=1>When drawing a flowchart that represents a complete algorithm, an oval symbol containing the word "Begin" is the first symbol used in the flowchart; an oval symbol containing the word "End" is the last symbol used. When drawing only a portion of an algorithm as in <a href="^Illustration::c:s0p3"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.1</a>, the oval symbols are omitted in favor of using small circle symbols also called connector symbols. <spacer width=16 height=1>Perhaps the most important flowcharting symbol is the diamond symbol, also called the decision symbol, that indicates a decision is to be made. We will discuss the diamond symbol in the next section. </page> <page> C++ provides three types of selection structures; we discuss each of these in this chapter. The if selection structure either performs (selects) an action if a condition is true or skips the action if the condition is false. The if/else selection structure performs an action if a condition is true and performs a different action if the condition is false. The switch selection structure performs one of many different actions depending on the value of an expression. <spacer width=16 height=1>The if selection structure is called a single-selection structure because it selects or ignores a single action. The if/else selection structure is called a double- selection structure because it selects between two </page> <page> different actions. The switch selection structure is called a multiple-selection structure because it selects the action to perform from many different actions. <spacer width=16 height=1>C++ provides three types of repetition structures, namely while, do/while and for. Each of the words if, else, switch, while, do, and for are C++ keywords. These words are reserved by the language to implement various features such as C++'s control structures. <a href="^Errors::c:s0p0"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>Keywords may not be used as identifiers such as for variable names. A complete list of C++ keywords is shown in <a href="^Illustration::c:s0p4"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.2</a>. Well, that is all there is. C++ has only seven control structures: sequence, three types of selection and three </page> <page> types of repetition. Each C++ program is formed by combining as many of each type of control structure as is appropriate for the algorithm the program implements. As with the sequence structure of <a href="^Illustration::c:s0p3"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.1</a>, we will see that each control structure is flowcharted with two small circle symbols, one at the entry point to the control structure and one at the exit point. These single-entry/single-exit control structures make it easy to build programs--the control structures are attached to one another by connecting the exit point of one control structure to the entry point of the next. This is similar to the way a child stacks building blocks, so we call this control-structure stacking. We will learn that </page> <page> there is only one other way control structures may be connected-- <a href="^Engineer::c:s0p0"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>a method called control-structure nesting. </page> <page> Drag the correct term to the box associated with the attribute: <component type="drag" width=72 height=18 label="selection" name="selection"> <component type="drag" width=80 height=18 label="repetition" name="repetition"> <component type="drag" width=64 height=18 label="keywords" name="keywords"> <component type="drag" width=72 height=18 label="flowlines" name="flowlines"> <component type="drag" width=80 height=18 label="structured" name="structured"> <component type="drag" width=64 height=18 label="decision" name="decision"> This flowchart symbol is also called the diamond symbol.<component type="drop" width=88 height=18 name="decision"> These cannot be used as variable names.<component type="drop" width=88 height=18 name="keywords"> The while loop is an example of this type of control structure.<component type="drop" width=88 height=18 name="repetition"> The arrows that connect flowchart symbols.<component type="drop" width=88 height=18 name="flowlines"> The if structure is an example of this type of control structure.<component type="drop" width=88 height=18 name="selection"> <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.5 The if Selection Structure"> <page> 2.5 The if Selection Structure<hr> A selection structure is used to choose among alternative courses of action. For example, suppose the passing grade on an exam is 60. The pseudocode statement <indent width=20>If student's grade is greater than or equal to 60 <spacer width=20 height=1>Print "Passed"</indent> determines if the condition "student's grade is greater than or equal to 60" is true or false. If the condition is true, then "Passed" is printed, and the next pseudocode statement in order is "performed" (remember that pseudocode is not a real programming language). If the </page> <page> condition is false, the print statement is ignored, and the next pseudocode statement in order is performed. Note that the second line of this selection structure is <a href="^Practice::c:s0p0"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>indented. Such indentation is optional, but it is highly recommended because it emphasizes the inherent structure of structured programs. When you covert your pseudocode into C++ code, the C++ compiler ignores whitespace characters like blanks, tabs and newlines used for indentation and vertical spacing. <spacer width=16 height=1>The preceding pseudocode If statement may be written in C++ as <pre> if ( grade >= 60 ) cout << "Passed"; </pre> </page> <page> Notice that the C++ code corresponds closely to the pseudocode. <a href="^Practice::c:s0p1"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>This is one of the properties of pseudocode that makes it such a useful program development tool. <spacer width=16 height=1>The flowchart of <a href="^Illustration::c:s0p5"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.3</a> illustrates the single-selection if structure. This flowchart contains what is perhaps the most important flowcharting symbol--the diamond symbol, also called the decision symbol, which indicates that a decision is to be made. The decision symbol contains an expression, such as a condition, that can be either true or false. The decision symbol has two flowlines emerging from it. One indicates the direction to be taken when the expression in the symbol is true; the other indicates the direction to be taken when the </page> <page> expression is false. We learned in Chapter 1 that decisions can be made based on conditions containing relational or equality operators. Actually, a decision can be made on any expression--if the expression evaluates to zero, it is treated as false, and if the expression evaluates to nonzero, it is treated as true. The C++ draft standard provides the data type bool to represent true and false. The keywords true and false are used to represent values of type bool. <spacer width=16 height=1>Note that the if structure, too, is a single-entry/single- exit structure. We will soon learn that the flowcharts for the remaining control structures also contain (besides small circle symbols and flowlines) only rectangle </page> <page> symbols to indicate the actions to be performed, and diamond symbols to indicate decisions to be made. This is the action/decision model of programming we have been emphasizing. <spacer width=16 height=1>We can envision seven bins, each containing only control structures of one of the seven types. These control structures are empty. Nothing is written in the rectangles or in the diamonds. The programmer's task, then, is assembling a program from as many of each type of control structure as the algorithm demands, combining those control structures in only two possible ways (stacking or nesting), and then filling in the actions and decisions in a manner appropriate for the </page> <page> algorithm. We will discuss the variety of ways in which actions and decisions may be written. </page> <page> Drag the correct term to the box associated with the attribute: <component type="drag" width=32 height=18 label="bool" name="bool"> <component type="drag" width=88 height=18 label="indentation" name="indentation"> <component type="drag" width=80 height=18 label="whitespace" name="whitespace"> These characters are ignored by the C++ compiler.<component type="drop" width=96 height=18 name="whitespace"> Data type, besides int, that has values of true and false.<component type="drop" width=96 height=18 name="bool"> Programmers use this technique to emphasize the structured nature of a program.<component type="drop" width=96 height=18 name="indentation"> <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.6 The if/else Selection Structure"> <page> 2.6 The if/else Selection Structure<hr> The if selection structure performs an indicated action only when the condition is true; otherwise the action is skipped. The if/else selection structure allows the programmer to specify that a different action is to be performed when the condition is true than when the condition is false. For example, the pseudocode statement <indent width=20>If student's grade is greater than or equal to 60 <spacer width=20 height=1>Print "Passed" else <spacer width=20 height=1>Print "Failed"</indent> </page> <page> prints Passed if the student's grade is greater than or equal to 60 and prints Failed if the student's grade is less than 60. In either case, after printing occurs, the next pseudocode statement in sequence is "performed." Note that the body of the else is also <a href="^Practice::c:s0p3"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>indented. <spacer width=16 height=1>Whatever in<a href="^Practice::c:s0p2"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>dentation convention you choose should be carefully applied throughout your programs. It is difficult to read programs that do not obey uniform spacing conventions. <spacer width=16 height=1>The preceding pseudocode If/else structure may be written in C++ as <pre> if ( grade >= 60 ) cout << "Passed"; </pre> </page> <page> <pre> else cout << "Failed"; </pre> The flowchart of <a href="^Illustration::c:s0p6"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.4</a> nicely illustrates the flow of control in the if/else structure. Once again, note that (besides small circles and arrows) the only symbols in the flowchart are rectangles (for actions) and a diamond (for a decision). We continue to emphasize this action/ decision model of computing. Imagine again a deep bin containing as many empty double-selection structures as might be needed to build any C++ program. The programmer's job is to assemble these selection structures (by stacking and nesting) with any other control structures required by the algorithm, and to fill </page> <page> in the empty rectangles and empty diamonds with actions and decisions appropriate to the algorithm being implemented. <spacer width=16 height=1>C++ provides the conditional operator (?:) that is closely related to the if/else structure. The conditional operator is C++'s only ternary operator--it takes three operands. The operands together with the conditional operator form a conditional expression. The first operand is a condition, the second operand is the value for the entire conditional expression if the condition is true, and the third operand is the value for the entire conditional expression if the condition is false. For example, the output statement </page> <page> <pre> cout << ( grade >= 60 ? "Passed" : "Failed" ); </pre> contains a conditional expression that evaluates to the string "Passed" if the condition grade >= 60 is true and evaluates to the string "Failed" if the condition is false. Thus, the statement with the conditional operator performs essentially the same as the preceding if/else statement. As we will see, the precedence of the conditional operator is low, so the parentheses in the preceding expression are required. The values in a conditional expression can also be actions to execute. For example, the conditional expression <pre> grade >= 60 ? cout << "Passed" : cout << "Failed"; </pre> </page> <page> is read, "If grade is greater than or equal to 60 then cout << "Passed", otherwise cout << "Failed"." This, too, is comparable to the preceding if/else structure. We will see that conditional operators can be used in some situations where if/else statements cannot. <spacer width=16 height=1>Nested if/else structures test for multiple cases by placing if/else selection structures inside if/else selection structures. For example, the following pseudocode statement will print A for exam grades greater than or equal to 90, B for grades in the range 80 to 89, C for grades in the range 70 to 79, D for grades in the range 60 to 69, and F for all other grades. <indent width=20>If student's grade is greater than or equal to 90</indent> </page> <page> <indent width=20><spacer width=20 height=1>Print "A" else <spacer width=20 height=1>If student's grade is greater than or equal to 80 <spacer width=20 height=1><spacer width=20 height=1>Print "B" <spacer width=20 height=1>else <spacer width=20 height=1><spacer width=20 height=1>If student's grade is greater than or equal to 70 <spacer width=20 height=1><spacer width=20 height=1><spacer width=20 height=1>Print "C" <spacer width=20 height=1><spacer width=20 height=1>else <spacer width=20 height=1><spacer width=20 height=1><spacer width=20 height=1>If student's grade is greater than or equal to 60 <spacer width=20 height=1><spacer width=20 height=1><spacer width=20 height=1><spacer width=20 height=1>Print "D" <spacer width=20 height=1><spacer width=20 height=1><spacer width=20 height=1>else <spacer width=20 height=1><spacer width=20 height=1><spacer width=20 height=1><spacer width=20 height=1>Print "F"</indent> This pseudocode may be written in C++ as <pre> if ( grade >= 90 ) cout << "A"; else </pre> </page> <page> <pre> if ( grade >= 80 ) cout << "B"; else if ( grade >= 70 ) cout << "C"; else if ( grade >= 60 ) cout << "D"; else cout << "F"; </pre> If grade is greater than or equal to 90, the first four conditions will be true, but only the cout statement after the first test will be executed. After that cout is executed, the else-part of the "outer" if/else statement is </page> <page> skipped. Many C++ programmers prefer to write the preceding if structure as <pre> if ( grade >= 90 ) cout << "A"; else if ( grade >= 80 ) cout << "B"; else if ( grade >= 70 ) cout << "C"; else if ( grade >= 60 ) cout << "D"; else cout << "F"; </pre> <a href="^Perform::c:s0p2"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>Both forms are equivalent. The latter form is popular because it avoids the deep indentation of the code to the right. Such indentation often leaves little room on a </page> <page> <a href="^Perform::c:s0p0"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>line, forcing lines to be split and decreasing program readability. <spacer width=16 height=1>The if selection structure expects only one statement in its body. To include several statements in the body of an if, enclose the statements in braces ({ and }). A set of statements contained within a pair of braces is <a href="^Engineer::c:s0p2"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>called a compound statement. <spacer width=16 height=1>The following example includes a compound statement in the else part of an if/else structure. <pre> if ( grade >= 60 ) cout << "Passed.\n";<spacer width=20 height=1> else { cout << "Failed.\n"; </pre> </page> <page> <pre> cout << "You must take this course again.\n"; } </pre> In this case, if grade is less than 60, the program executes both statements in the body of the else and prints <pre> Failed. You must take this course again. </pre> Notice the braces surrounding the two statements in the else clause. <a href="^Errors::c:s0p1"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>These braces are important. Without the braces, the statement <pre> cout << "You must take this course again.\n"; </pre> </page> <page> would be outside the body of the else-part of the if, and would <a href="^Practice::c:s0p4"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>execute regardless of whether the grade is less than 60. <spacer width=16 height=1> <a href="^Errors::c:s0p2"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>A syntax error is caught by the compiler. A logic error has its effect at execution time. A fatal logic error causes <a href="^Practice::c:s0p5"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>a program to fail and terminate prematurely. A nonfatal logic error allows a program to continue <a href="^Engineer::c:s0p3"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a> executing but the program produces incorrect results. <spacer width=16 height=1>In this section, we introduced the notion of a compound statement. A compound statement may contain declarations (as does the body of main, for example). If so, the compound statement is called a block. The declarations in a block are commonly placed first in the </page> <page> block before any action statements, but declarations may be intermixed with action statements. We will discuss the use of blocks in Chapter 3. The reader should avoid using blocks (other than as the body of main, of course) until that time. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The if structure performs an indicated action only when the condition is true. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> if/else structures can be nested in other control structures. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> C++ is a case-sensitive language. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The conditional operator is a ternary operator."> The conditional operator, ?:, is a binary operator. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The compiler associates an else with the closest if unless specified otherwise using braces {}. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.7 The while Repetition Structure"> <page> 2.7 The while Repetition Structure<hr> A repetition structure allows the programmer to specify that an action is to be repeated while some condition remains true. The pseudocode statement <indent width=20>While there are more items on my shopping list <spacer width=20 height=1>Purchase next item and cross it off my list</indent> describes the repetition that occurs during a shopping trip. The condition, "there are more items on my shopping list" may be true or false. If it is true, then the action, "Purchase next item and cross it off my list" is performed. This action will be performed repeatedly while the condition remains true. The statement(s) </page> <page> contained in the while repetition structure constitute the body of the while. The while structure body may be a single statement or a compound statement. <a href="^Errors::c:s0p5"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>Eventually, the condition will become false (when the last item on the shopping list has been purchased and crossed off the list). At this point, the repetition terminates, and the first pseudocode statement after the repetition structure is executed. <spacer width=16 height=1>As an example of an <a href="^Errors::c:s0p3"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>actual while, consider a program segment designed to find the first power of 2 larger than 1000. Suppose the integer variable product has been initialized to 2. When the following while repetition </page> <page> structure finishes executing, product will contain the desired answer: <pre> int product = 2; while ( product <= 1000 ) product = 2 * product; </pre> The flowchart of <a href="^Illustration::c:s0p7"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.5</a> illustrates the flow of control in the while structure that corresponds to the preceding while structure. Once again, note that (besides small circles and arrows) the flowchart contains only a rectangle symbol and a diamond symbol. Imagine a deep bin of empty while structures that may be stacked and nested with other control structures to form a structured implementation of an algorithm's flow of </page> <page> control. The empty rectangles and diamonds are then filled in with appropriate actions and decisions. The flowchart clearly shows the repetition. The flowline emerging from the rectangle wraps back to the decision that is tested each time through the loop until the decision becomes false. Then, the while structure exits and control passes to the next statement in the program. When the while structure is entered, the value of product is 2. The variable product is repeatedly multiplied by 2, taking on the values 4, 8, 16, 32, 64, 128, 256, 512, and 1024 successively. When product becomes 1024, the while structure condition, product </page> <page> <= 1000, becomes false. This terminates the repetition--the final value of product is 1024. Program execution continues with the next statement after the while. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The while repetition structure has one statement by default."> The while repetition structure has two statements in the body by default. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> If the while loop's condition is initially false, the loop's body will not be executed. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Repetition structures allow statements to be repeated until some condition becomes false. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.8 Formulating Algorithms: Case Study 1 (Counter-Controlled Repetition)"> <page> 2.8 Formulating Algorithms: Case Study 1 (Counter-Controlled Repetition)<hr> To illustrate how algorithms are developed, we solve several variations of a class averaging problem. Consider the following problem statement: <indent width=16>A class of ten students took a quiz. The grades (integers in the range 0 to 100) for this quiz are available to you. Determine the class average on the quiz.</indent> The class average is equal to the sum of the grades divided by the number of students. The algorithm for solving this problem on a computer must input each of </page> <page> the grades, perform the averaging calculation, and print the result. <spacer width=16 height=1>Let us use pseudocode to list the actions to be executed and specify the order in which these actions should be executed. We use counter-controlled repetition to input the grades one at a time. This technique uses a variable called a counter to control the number of times a set of statements will execute. In this example, repetition terminates when the counter exceeds 10. In this section, we present a pseudocode algorithm ( <a href="^Illustration::c:s0p8"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.6</a>) and the corresponding program (<a href="^Code::c:s0p0"> </a> <a href="^Code::c:s0p0"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.7</a>). In the next section, we show how pseudocode algorithms are developed. Counter-controlled repetition is often called definite </page> <page> repetition because the number of repetitions is known before the loop begins executing. <spacer width=16 height=1>Note the references in the algorithm to a total and a counter. A total is a variable used to accumulate the sum of a series of values. A counter is a variable used to count--in this case, to count the number of grades entered. Variables used to store totals should normally be initialized to zero before being used in a program; otherwise, the sum would include the previous value stored in the total's memory location. <spacer width=16 height=1>Counter variables are normally <a href="^Practice::c:s0p6"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>initialized to zero or one, depending on their use (we will present examples showing each of these uses). <a href="^Errors::c:s0p7"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>An uninitialized variable </page> <page> contains a "garbage" value (also called an undefined value)--the value last stored in the memory location reserved for that <a href="^Practice::c:s0p7"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>variable. <spacer width=16 height=1>Note that the averaging calculation in the program produced an integer result. Actually, the sum of the grades in this example is 817 which when divided by 10 should yield 81.7, i.e., a number with a decimal point. We will see how to deal with such numbers (called floating-point numbers) in the next section. <spacer width=16 height=1>In <a href="^Code::c:s0p0"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.7</a>, if line 25 <a href="^Errors::c:s0p8"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>used gradeCounter rather than 10 for the calculation, the output for this program would display a value of 74. </page> </section> <section type=Body name=Default title="2.9 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel-Controlled Repetition)"> <page> 2.9 Formulating Algorithms with Top- Down, Stepwise Refinement: Case Study 2 (Sentinel-Controlled Repetition)<hr> Let us generalize the class average problem. Consider the following problem: <indent width=16>Develop a class averaging program that will process an arbitrary number of grades each time the program is run.</indent> In the first class average example, the number of grades (10) was known in advance. In this example, no indication is given of how many grades are to be entered. The program must process an arbitrary number </page> <page> of grades. How can the program determine when to stop the input of grades? How will it know when to calculate and print the class average? <spacer width=16 height=1>One way to solve this problem is to use a special value called a sentinel value (also called a signal value, a dummy value, or a flag value) to indicate "end of data entry." The user types grades in until all legitimate grades have been entered. The user then types the sentinel value to indicate that the last grade has been entered. Sentinel-controlled repetition is often called indefinite repetition because the number of repetitions is not known before the loop begins executing. </page> <page> <a href="^Errors::c:s0p10"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>Clearly, the sentinel value must be chosen so that it cannot be confused with an acceptable input value. Because grades on a quiz are normally nonnegative integers, 1 is an acceptable sentinel value for this problem. Thus, a run of the class average program might process a stream of inputs such as 95, 96, 75, 74, 89, and 1. The program would then compute and print the class average for the grades 95, 96, 75, 74, and 89 ( 1 is the sentinel value, so it should not enter into the averaging calculation). <spacer width=16 height=1>We approach the class average program with a technique called top-down, stepwise refinement, a technique that is essential to the development of well- </page> <page> structured programs. We begin with a pseudocode representation of the top: <indent width=20>Determine the class average for the quiz</indent> The top is a single statement that conveys the overall function of the program. As such, the top is, in effect, a complete representation of a program. Unfortunately, the top (as in this case) rarely conveys a sufficient amount of detail from which to write the C++ program. So we now begin the refinement process. We divide the top into a series of smaller tasks and list these in the order in which they need to be performed. This results in the following first refinement. <indent width=20>Initialize variables</indent> </page> <page> <indent width=20>Input, sum, and count the quiz grades Calculate and print the class average</indent> Here, only the sequence structure has been used--the <a href="^Engineer::c:s0p7"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>steps listed are to be executed in order, one after the other. <spacer width=16 height=1> <a href="^Engineer::c:s0p5"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>The preceding Software Engineering Observation is often all you need for the first refinement in the top- down process. To proceed to the next level of refinement, i.e., the second refinement, we commit to specific variables. We need a running total of the numbers, a count of how many numbers have been processed, a variable to receive the value of each grade </page> <page> as it is input, and a variable to hold the calculated average. The pseudocode statement <indent width=20>Initialize variables</indent> may be refined as follows: <indent width=20>Initialize total to zero<spacer width=20 height=1> Initialize counter to zero<spacer width=20 height=1></indent> Notice that only the variables total and counter need to be initialized before they are used; the variables average and grade (for the calculated average and the user input, respectively) need not be initialized because their values will be written over as they are calculated or input. <spacer width=16 height=1>The pseudocode statement </page> <page> <indent width=20>Input, sum, and count the quiz grades</indent> requires a repetition structure (i.e., a loop) that successively inputs each grade. Because we do not know in advance how many grades are to be processed, we will use sentinel-controlled repetition. The user will type legitimate grades in one at a time. After the last legitimate grade is typed, the user will type the sentinel value. The program will test for the sentinel value after each grade is input and will terminate the loop when the sentinel value is entered by the user. The second refinement of the preceding pseudocode statement is then <indent width=20>Input the first grade (possibly the sentinel)</indent> </page> <page> <indent width=20>While the user has not as yet entered the sentinel <spacer width=20 height=1>Add this grade into the running total <spacer width=20 height=1>Add one to the grade counter <spacer width=20 height=1>Input the next grade (possibly the sentinel)</indent> Notice that in pseudocode, we do not use braces around the set of statements that form the body of the while structure. We simply indent the statements under the while to show that they belong to the while. Again, pseudocode is only an informal program development aid. <spacer width=16 height=1>The pseudocode statement <indent width=20>Calculate and print the class average</indent> may be refined as follows: </page> <page> <indent width=20>If the counter is not equal to zero <spacer width=20 height=1>Set the average to the total divided by the counter <spacer width=20 height=1>Print the average else <spacer width=20 height=1>Print "No grades were entered"</indent> Notice that we are being careful here to test for the possibility of div<a href="^Errors::c:s0p11"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>ision by zero--a fatal logic error that if undetected would cause the <a href="^Practice::c:s0p8"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>program to fail (often called "bombing" or "crashing"). The complete second refinement of the pseudocode for the class average problem is shown in <a href="^Illustration::c:s0p9"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.8</a>. <spacer width=16 height=1>In <a href="^Illustration::c:s0p8"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.6</a> and <a href="^Illustration::c:s0p9"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.8</a>, we include some completely blank lines in the pseudocode to make the pseudocode </page> <page> more readable. The blank lines separate these programs into their various phases. <spacer width=16 height=1>The pseudocode algorithm in <a href="^Illustration::c:s0p9"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.8</a> solves the more general class averaging problem. This algorithm was developed after only two levels of refinement. <a href="^Engineer::c:s0p8"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>Sometimes more levels are necessary. <spacer width=16 height=1>The C++ program and a sample execution are shown in <a href="^Code::c:s0p1"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.9</a>. Although only integer grades are entered, the averaging calculation is likely to produce a number with a decimal point, i.e., a real number. The type int cannot represent real numbers. The program introduces the data type float to handle numbers with decimal points (also called floating-point numbers) and </page> <page> introduces a special operator called a cast operator to handle the averaging calculation. These features are explained in detail after the program is presented. <spacer width=16 height=1>Notice the compound statement in the while loop in <a href="^Code::c:s0p1"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig 2.9</a>. Without the braces, the last three statements in the body of the loop would fall outside the loop, causing the computer to interpret this code incorrectly as follows <pre> while ( grade != -1 ) total = total + grade; gradeCounter = gradeCounter + 1; cout << "Enter grade, -1 to end: "; cin >> grade; </pre> </page> <page> This would cause an infinite loop if the user does not input 1 for the first grade. <spacer width=16 height=1>Notice that the statement <pre> cin >> grade; </pre> is preceded by an output statement that <a href="^Practice::c:s0p11"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>prompts the user for input. <spacer width=16 height=1>Averages do not <a href="^Practice::c:s0p10"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>always evaluate to integer values. Often, an average is a value such as 7.2 or -93.5 that contains a fractional part. These values are referred to as floating-point numbers and are represented by the data type float. The variable average is declared to be of type float to capture the fractional result of our calculation. However, the result of the calculation total </page> <page> / counter is an integer because total and counter are both integer variables. Dividing two integers results in integer division in which any fractional part of the calculation is lost (i.e., truncated). Because the calculation is performed first, the fractional part is lost before the result is assigned to average. To produce a floating-point calculation with integer values, we must create temporary values that are floating-point numbers for the calculation. C++ provides the unary cast operator to accomplish this task. The statement <pre> average = static_cast< float >( total ) / gradeCounter; </pre> </page> <page> includes the cast operator static_cast< float >() which creates a temporary floating-point copy of its operand in parentheses--total. Using a cast operator in this manner is called explicit conversion. The value stored in total is still an integer. The calculation now consists of a floating-point value (the temporary float version of total) divided by the integer counter. <spacer width=16 height=1>The C++ compiler only knows how to evaluate expressions in which the data types of the operands are identical. To ensure that the operands are of the same type, the compiler performs an operation called promotion (also called implicit conversion) on selected operands. For example, in an expression containing the </page> <page> data types int and float, int operands are promoted to float. In our example, after counter is promoted to float, the calculation is performed and the result of the floating-point division is assigned to average. Later in this chapter we discuss all the standard data types and their order of promotion. <spacer width=16 height=1>Cast operators are available for any data type. The static_cast operator is formed by following keyword static_cast with angle brackets (< and >) around a data type name. The cast operator is a unary operator, i.e., an operator that takes only one operand. In Chapter 1, we studied the binary arithmetic operators. C++ also supports unary versions of the plus (+) and minus (-) </page> <page> operators, so the programmer can write expressions like -7 or +5. Cast operators associate from right to left and have higher precedence than other unary operators such as unary + and unary -. This precedence is higher than that of the multiplicative operators *, /, and %, and lower than that of parentheses. We indicate the cast operator with the notation static_cast< type>() in our precedence charts. <spacer width=16 height=1>The formatting capabilities in <a href="^Code::c:s0p1"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.9</a> are explained in depth in Chapter 11 and discussed here briefly. The call setprecision(2) in the output statement </page> <page> <pre> cout << "Class average is " << setprecision( 2 ) << setiosflags(ios::fixed | ios::showpoint) << average << endl; </pre> indicates that float variable average is to be printed with two digits of precision to the right of the decimal point (e.g., 92.37). This call is referred to as a parameterized stream manipulator. Programs that use these calls must contain the preprocessor directive <pre> #include <iomanip.h> </pre> Note that endl is a nonparameterized stream manipulator and does not require the iomanip.h header file. If the precision is not specified, floating-point values are normally output with six digits of precision </page> <page> (i.e., the default precision), although we will see an exception to this in a moment. <spacer width=16 height=1>The stream manipulator setiosflags( ios::fixed | ios::showpoint ) in the preceding statement sets two output formatting options, namely ios::fixed and ios::showpoint. The vertical bar character (|) separates multiple options in a setiosflags call (we will explain the | notation in depth in Chapter 16). The option ios::fixed causes a floating-point value to be output in so-called fixed-point format (as opposed to scientific notation which we will discuss in Chapter 11). The ios::showpoint option forces the decimal point and trailing zeros to print even if the value is a whole </page> <page> number amount such as 88.00. Without the ios::showpoint option, such a value prints in C++ as 88 without the trailing zeros and without the decimal point. <a href="^Errors::c:s0p12"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>When the preceding formatting is used in a program, the printed <a href="^Practice::c:s0p12"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>value is rounded to the indicated number of decimal positions, although the value in memory remains unaltered. For example, the values 87.945 and 67.543 are output as 87.95 and 67.54, respectively. <spacer width=16 height=1>Despite the fact that floating-point numbers are not always "100% precise," they have numerous applications. For example, when we speak of a "normal" body temperature of 98.6 we do not need to be precise to a large number of digits. When we view </page> <page> the temperature on a thermometer and read it as 98.6, it may actually be 98.5999473210643. The point here is that calling this number simply 98.6 is fine for most applications. <spacer width=16 height=1>Another way floating-point numbers develop is through division. When we divide 10 by 3, the result is 3.3333333\xc9 with the sequence of 3s repeating infinitely. The computer allocates only a fixed amount of space to hold such a value, so clearly the stored floating-point value can only be an approximation. </page> <page> Drag the correct term to the box associated with the attribute: <component type="drag" width=152 height=18 label="sentinel-controlled" name="sentinel-controlled"> <component type="drag" width=144 height=18 label="counter-controlled" name="counter-controlled"> <component type="drag" width=24 height=18 label="int" name="int"> <component type="drag" width=88 height=18 label="static_cast" name="static_cast"> Dividing 22 by 8 yields this data type.<component type="drop" width=160 height=18 name="int"> Type of repetition where the number of repetitions is not known in advance.<component type="drop" width=160 height=18 name="sentinel-controlled"> Operator used to convert from one data type to another.<component type="drop" width=160 height=18 name="static_cast"> Type of repetition where the number of repetitions in known in advance.<component type="drop" width=160 height=18 name="counter-controlled"> <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.10 Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)"> <page> 2.10 Formulating Algorithms with Top- Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)<hr> Let us work another complete problem. We will once again formulate the algorithm using pseudocode and top-down, stepwise refinement, and write a corresponding C++ program. We have seen that control structures may be stacked on top of one another (in sequence) just as a child stacks building blocks. In this case study we will see the only other structured way control structures may be connected in C++, namely through nesting of one control structure within another. </page> <page> Consider the following problem statement: <indent width=16>A college offers a course that prepares students for the state licensing exam for real estate brokers. Last year, several of the students who completed this course took the licensing examination. Naturally, the college wants to know how well its students did on the exam. You have been asked to write a program to summarize the results. You have been given a list of these 10 students. Next to each name is written a 1 if the student passed the exam and a 2 if the student failed.</indent> Your program should analyze the results of the exam as follows: </page> <page> 1. Input each test result (i.e., a 1 or a 2). Display the message "Enter result" on the screen each time the program requests another test result. 2. Count the number of test results of each type. 3. Display a summary of the test results indicating the number of students who passed and the number of students who failed. 4. If more than 8 students passed the exam, print the message "Raise tuition." After reading the problem statement carefully, we make the following observations: </page> <page> 1. The program must process 10 test results. A counter- controlled loop will be used. 2. Each test result is a number--either a 1 or a 2. Each time the program reads a test result, the program must determine if the number is a 1 or a 2. We test for a 1 in our algorithm. If the number is not a 1, we assume that it is a 2. (An exercise at the end of the chapter considers the consequences of this assumption.) 3. Two counters are used--one to count the number of students who passed the exam and one to count the number of students who failed the exam. 4. After the program has processed all the results, it must decide if more than 8 students passed the exam. </page> <page> Let us proceed with top-down, stepwise refinement. We begin with a pseudocode representation of the top: <indent width=20>Analyze exam results and decide if tuition should be raised</indent> Once again, it is important to emphasize that the top is a complete representation of the program, but several refinements are likely to be needed before the pseudocode can be naturally evolved into a C++ program. Our first refinement is <indent width=20>Initialize variables Input the ten quiz grades and count passes and failures Print a summary of the exam results and decide if tuition should be raised</indent> </page> <page> Here, too, even though we have a complete representation of the entire program, further refinement is necessary. We now commit to specific variables. Counters are needed to record the passes and failures, a counter will be used to control the looping process, and a variable is needed to store the user input. The pseudocode statement <indent width=20>Initialize variables</indent> may be refined as follows: <indent width=20>Initialize passes to zero<spacer width=20 height=1> Initialize failures to zero<spacer width=20 height=1> Initialize student counter to one<spacer width=20 height=1></indent> </page> <page> Notice only the counters and totals are initialized. The pseudocode statement <indent width=20>Input the ten quiz grades and count passes and failures</indent> requires a loop that successively inputs the result of each exam. Here it is known in advance that there are precisely ten exam results, so counter-controlled looping is appropriate. Inside the loop (i.e., nested within the loop) a double-selection structure will determine whether each exam result is a pass or a failure, and will increment the appropriate counter accordingly. The refinement of the preceding pseudocode statement is then <indent width=20>While student counter is less than or equal to ten</indent> </page> <page> <indent width=20><spacer width=20 height=1>Input the next exam result</indent> <indent width=20><spacer width=20 height=1>If the student passed <spacer width=20 height=1><spacer width=20 height=1>Add one to passes <spacer width=20 height=1>else <spacer width=20 height=1><spacer width=20 height=1>Add one to failures</indent> <indent width=20><spacer width=20 height=1>Add one to student counter</indent> Notice the use of blank lines to set off the If/else control structure to improve program readability. The pseudocode statement <indent width=20>Print a summary of the exam results and decide if tuition should be raised</indent> may be refined as follows: <indent width=20>Print the number of passes Print the number of failures</indent> </page> <page> <indent width=20>If more than eight students passed <spacer width=20 height=1>Print "Raise tuition"</indent> The complete second refinement appears in <a href="^Illustration::c:s0p10"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.10</a>. Notice that blank lines are also used to set off the while structure for program readability. <spacer width=16 height=1> <a href="^Engineer::c:s0p10"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>This pseudocode is now sufficiently refined for conversion to C++. The C++ program and two sample executions are shown in <a href="^Code::c:s0p2"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.11</a>. Note that we have taken advantage of a feature of C++ that allows variable initialization to be incorporated into declarations. Looping programs may require initialization at the beginning of each repetition; such <a href="^Practice::c:s0p13"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>initialization would <a href="^Engineer::c:s0p12"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>normally occur in assignment statements. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> C++ allows variable initialization to be incorporated into declarations. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Variables normally contain "garbage" values by default."> Variables are initialized to 0 by default. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The most difficult part of solving a computer problem is usually developing the algorithm. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.11 Assignment Operators"> <page> 2.11 Assignment Operators<hr> C++ provides several assignment operators for abbreviating assignment expressions. For example the statement <pre> c = c + 3; </pre> can be abbreviated with the addition assignment operator += as <pre> c += 3; </pre> The += operator adds the value of the expression on the right of the operator to the value of the variable on the left of the operator and stores the result in the variable on the left of the operator. Any statement of the form </page> <page> <pre> variable = variable operator expression; </pre> where ope<a href="^Perform::c:s0p3"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>rator is one of the binary operators +, -, *, /, or % (or others we will discuss later in the text), can be written in the form <pre> variable operator= expression; </pre> Thus the assignment c += 3 adds 3 to c. <a href="^Illustration::c:s0p11"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.12</a> shows the arithmetic assignment operators, sample <a href="^Perform::c:s0p5"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>expressions using these operators, and explanations. </page> <page> Drag the correct term to the box associated with the attribute: <component type="drag" width=16 height=18 label="%=" name="%="> <component type="drag" width=16 height=18 label="*=" name="*="> <component type="drag" width=16 height=18 label="-=" name="-="> <component type="drag" width=16 height=18 label="/=" name="/="> <component type="drag" width=16 height=18 label="+=" name="+="> <component type="drag" width=16 height=18 label="!=" name="!="> <component type="drag" width=8 height=18 label="=" name="="> <component type="drag" width=16 height=18 label="==" name="=="> Modulus assignment operator.<component type="drop" width=24 height=18 name="%="> Division assignment operator.<component type="drop" width=24 height=18 name="/="> Equality operator.<component type="drop" width=24 height=18 name="=="> Subtraction assignment operator.<component type="drop" width=24 height=18 name="-="> InEquality operator.<component type="drop" width=24 height=18 name="!="> Addition assignment operator.<component type="drop" width=24 height=18 name="+="> Multiplication assignment operator.<component type="drop" width=24 height=18 name="*="> Assignment operator.<component type="drop" width=24 height=18 name="="> <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.12 Increment and Decrement Operators"> <page> 2.12 Increment and Decrement Operators<hr> C++ also provides the ++ unary increment operator and the -- unary decrement operator that are summarized in <a href="^Illustration::c:s0p12"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.13</a>. If a variable c is incremented by 1, the increment operator ++ can be used rather than the expressions c = c + 1 or c += 1. If an increment or decrement operator is placed before a variable, it is referred to as the preincrement or predecrement operator, respectively. If an increment or decrement operator is placed after a variable, it is referred to as the postincrement or postdecrement operator, respectively. Preincrementing (predecrementing) a variable causes </page> <page> the variable to be incremented (decremented) by 1, then the new value of the variable is used in the expression in which it appears. Postincrementing (postdecrementing) a variable causes the current value of the variable to be used in the expression in which it appears, then the variable value is incremented (decremented) by 1. <spacer width=16 height=1>The program of <a href="^Code::c:s0p3"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.14</a> demonstrates the difference between the preincrementing version and the postincrementing version of the ++ operator. Postincrementing the variable c causes it to be incremented after it is used in the output statement. </page> <page> Preincrementing the variable c causes it to be incremented before it is used in the output statement. <spacer width=16 height=1>The program displays the value of c before and after the ++ operator is used. <a href="^Practice::c:s0p14"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>The decrement operator (--) works similarly. <spacer width=16 height=1>The three assignment statements in <a href="^Code::c:s0p2"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig 2.11 </a> <pre> passes = passes + 1; failures = failures + 1; student = student + 1; </pre> can be written more concisely with assignment operators as <pre> passes += 1; failures += 1; student += 1; </pre> </page> <page> with preincrement operators as <pre> ++passes; ++failures; ++student; </pre> or with postincrement operators as <pre> passes++; failures++; student++; </pre> Note that when incrementing or decrementing a variable in a statement by itself, the preincrement and postincrement forms have the same effect, and the predecrement and postdecrement forms have the same effect. It is only when a variable appears in the context </page> <page> of a larger expression that preincrementing the variable and postincrementing the variable have different effects (and similarly for predecrementing and postdecrementing). <spacer width=16 height=1><a href="^Errors::c:s0p13"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>For now, only a simple variable name may be used as the operand of an increment or decrement operator (we will see that these operators may be used on so-called lvalues). <spacer width=16 height=1><a href="^Illustration::c:s0p13"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.15</a> shows the precedence and associativity of the operators introduced to this point. The operators are shown top-to-bottom in decreasing order of precedence. The second column describes the associativity of the operators at each level of precedence. Notice that the </page> <page> conditional operator (?:), the unary operators increment (++), decrement (--), plus (+), minus (-) and casts, and the assignment operators =, +=, -=, *=, /= and %= associate from right to left. All other operators in the operator precedence chart of <a href="^Illustration::c:s0p13"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.15</a> associate from left to right. The third column names the various groups of operators. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The unary decrement operator subtracts one from a variable. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The associativity is right to left."> The increment operator has left-to-right associativity. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The increment and decrement operators can only be applied to variables."> The following expression is valid: cout << ++8;. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. In the context of larger expressions, predecrementing or postdecrementing can produce different results."> Predecrementing and postdecrementing are always equivalent; regardless of the expression. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.13 Essentials of Counter-Controlled Repetition"> <page> 2.13 Essentials of Counter-Controlled Repetition<hr> Counter-controlled repetition requires: 1. The name of a control variable (or loop counter). 2. The initial value of the control variable. 3. The condition that tests for the final value of the control variable (i.e., whether looping should continue). 4. The increment (or decrement) by which the control variable is modified each time through the loop. Consider the simple program shown in <a href="^Code::c:s0p4"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.16</a>, which prints the numbers from 1 to 10. The declaration <pre> int counter = 1; </pre> </page> <page> names the control variable (counter), declares it to be an integer, reserves space for it in memory, and sets it to an initial value of 1. Declarations that require initialization are, in effect, executable statements. In C++, it is more precise to call a declaration that also reserves memory--as the preceding declaration does-- a definition. <spacer width=16 height=1>The declaration and initialization of counter also could have been accomplished with the statements <pre> int counter; counter = 1; </pre> The declaration is not executable, but the assignment is. We use both methods of initializing variables. </page> <page> The statement <pre> ++counter; </pre> increments the loop counter by 1 each time the loop is performed. The loop-continuation condition in the while structure tests if the value of the control variable is less than or equal to 10 (the last value for which the condition is true). Note that the <a href="^Practice::c:s0p15"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>body of this while is performed even when the control variable is 10. The loop terminates when the control variable exceeds 10 (i.e., counter becomes 11). <spacer width=16 height=1><a href="^Practice::c:s0p18"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar> </a>The program in <a href="^Code::c:s0p4"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.16</a> can be made more concise by initializing counter to 0 and by replacing the while structure with </page> <page> <pre> while ( ++counter <= 10 ) cout << counter << endl; </pre> <a href="^Practice::c:s0p16"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>This code saves a statement because the incrementing is done directly in the while condition before the condition is tested. <a href="^Practice::c:s0p17"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>Also, this code eliminates the braces around <a href="^Errors::c:s0p14"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>the body of the while because the while now contains only one statement. Coding in such a condensed <a href="^Practice::c:s0p19"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>fashion takes some practice. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Declarations are not considered executable statements. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. A variable can be incremented in the while loop condition."> A variable cannot be incremented in a while loop's condition. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.14 The for Repetition Structure"> <page> 2.14 The <tt>for</tt> Repetition Structure<hr> The for repetition structure handles all the details of counter-controlled repetition. To illustrate the power of for, let us rewrite the program of <a href="^Code::c:s0p4"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.16</a>. The result is shown in <a href="^Code::c:s0p5"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.17</a>. The program operates as follows. <spacer width=16 height=1>When the for structure begins executing, the control variable counter is declared and initialized to 1. Then, the loop-continuation condition counter <= 10 is checked. Because the initial value of counter is 1, the condition is satisfied, so the body statement prints the value of counter, namely 1. The control variable counter is then incremented in the expression </page> <page> counter++, and the loop begins again with the loop- continuation test. Because the control variable is now equal to 2, the final value is not exceeded, so the program performs the body statement again. This process continues until the control variable counter is incremented to 11--this causes the loop-continuation test to fail and repetition terminates. The program continues by performing the first statement after the for structure (in this case, the return statement at the end of the program). <spacer width=16 height=1> <a href="^Illustration::c:s0p14"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.18</a> takes a closer look at the for structure of <a href="^Code::c:s0p5"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.17</a>. Notice that the for structure "does it all"--it specifies each of the items needed for counter- </page> <page> controlled repetition with a control variable. If there is more than one statement in the body of the for, braces are required to define the body of the loop. <spacer width=16 height=1>Notice that <a href="^Code::c:s0p5"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.17</a> uses the loop-continuation condition counter <= 10. If the programmer incorrectly wrote counter < 10, then the loop would be executed only 9 times. <a href="^Errors::c:s0p15"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>This is a common logic error <a href="^Practice::c:s0p21"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>called an off-by-one error. The general format of the for structure is <pre> for ( expression1; expression2; expression3 ) statement </pre> where expression1 initializes the loop's control variable, expression2 is the loop-continuation </page> <page> condition, and expression3 increments the control variable. In most cases the for structure can be represented with an equivalent while structure as follows: <pre> expression1; while ( expression2 ) { statement expression3; } </pre> There is an exception to this rule which we will discuss in <a href="#s18p0">Section 2.18</a>. <spacer width=16 height=1>If expression1 (the initialization section) in the for structure header defines the control variable (i.e., the </page> <page> control variable's type is specified before the variable name), the control variable can only be used in the body of the for structure, i.e., the value of the control variable will be unknown outside the for structure. <a href="^Errors::c:s0p16"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>This restricted use of the control variable name is known as the variable's scope. The sc<a href="^Portable::c:s0p0"><img src="bckgrnds/icons/port_ico.gif" align=sidebar></a>ope of a variable defines where it can be used in a program. Scope is discussed in detail in Chapter 3, "Functions." <spacer width=16 height=1>Sometimes, expression1 and expression3 are comma- separated lists of expressions. The commas as used here are comma operators that guarantee lists of expressions evaluate left to right. The comma operator has the lowest precedence of all operators in C++. The value </page> <page> and type of a comma-separated list of expressions is the value and type of the rightmost expression in the list. The comma operator is most often used in for structures. Its primary application is to enable the programmer to use multiple <a href="^Practice::c:s0p24"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>initialization expressions and/or multiple increment expressions. For example, there may be several control variables in a single for structure that must be initialized and incremented. <spacer width=16 height=1>The three expressions in the for structure are optional. If expression2 is omitted, C++ assumes that the loop- continuation condition is true, thus creating an infinite loop. One might omit expression1 if the control variable is initialized elsewhere in the program. expression3 </page> <page> might be omitted if the increment is calculated by statements in the body of the for or if no increment is needed. The increment expression in the for structure acts like a stand-alone statement at the end of the body of the for. Therefore, the expressions <pre> counter = counter + 1 counter += 1 ++counter counter++ </pre> are all equivalent in the incrementing portion of the for structure. Many programmers prefer the form counter++ because the incrementing occurs after the loop body is executed. The postincrementing form </page> <page> therefore seems more natural. Because the variable being incremented here does not appear in an expression, both preincrementing and postincrementing have the same effect. <a href="^Errors::c:s0p19"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>The two semicolons in the for structure <a href="^Errors::c:s0p18"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>are required. <spacer width=16 height=1> <a href="^Engineer::c:s0p14"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>The initialization, loop-continuation condition, and increment portions of a for structure can contain arithmetic expressions. For example, assume that x = 2 and y = 10. If x and y are not modified in the loop body, the statement <pre> for ( int j = x; j <= 4 * x * y; j += y / x ) </pre> is equivalent to the statement <pre> for ( int j = 2; j <= 80; j += 5 ) </pre> </page> <page> The "increment" of a for structure may be negative (in which case it is really a decrement and the loop actually counts downwards). <spacer width=16 height=1>If the loop-continuation condition is initially false, the body of the for structure is not performed. Instead, execution proceeds with the statement following the for. <spacer width=16 height=1>The control variable is frequently printed or used in calculations in the body of a for structure, but it does not have to be. <a href="^Practice::c:s0p26"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>It is common to use the control variable for controlling repetition while never mentioning it in the body of the for structure. </page> <page> The for structure is flowcharted much like the while structure. For example, the flowchart of the for statement <pre> for ( int counter = 1; counter <= 10; counter++ ) cout << counter << endl; </pre> is shown in<a href="^Illustration::c:s0p15"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.19</a>. This flowchart makes it clear that the initialization occurs only once and that incrementing occurs each time after the body statement is performed. Note that (besides small circles and arrows) the flowchart contains only rectangle symbols and a diamond symbol. Imagine, again, that the programmer has access to a deep bin of empty for structures--as many as the programmer might need to </page> <page> stack and nest with other control structures to form a structured implementation of an algorithm's flow of control. And again, the rectangles and diamonds are then filled with actions and decisions appropriate to the algorithm. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> If there is more than one statement in the body of a for, braces are required to define the for's body. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The two semicolons within the for header are required syntax. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The for loop always executes when the condition is true."> If a for loop's condition is initially true, the for loop will not be executed. <component type="checkbox" width=20 height=18 label="" name="" correct=".True."> The control variable used in a for loop does not have to be used in the body of the for loop <component type="checkbox" width=20 height=18 label="" name="" correct="True."> In a for structure, initialization only occurs once. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.15 Examples Using the for Structure"> <page> 2.15 Examples Using the <tt>for</tt> Structure<hr> The following examples show methods of varying the control variable in a for structure. In each case, we write the appropriate for header. <a href="^Errors::c:s0p20"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>Note the change in the relational operator for loops that decrement the control variable. 1. <spacer width=20 height=1>Vary the control variable from 1 to 100 in increments of 1. <pre> for ( int i = 1; i <= 100; i++ ) </pre> 2. <spacer width=20 height=1>Vary the control variable from 100 to 1 in increments of -1 (decrements of 1). <pre> for ( int i = 100; i >= 1; i-- ) </pre> </page> <page> 3. <spacer width=20 height=1>Vary the control variable from 7 to 77 in steps of 7. <pre> for ( int i = 7; i <= 77; i += 7 ) </pre> 4. <spacer width=20 height=1>Vary the control variable from 20 to 2 in steps of -2. <pre> for ( int i = 20; i >= 2; i -= 2 ) </pre> 5. <spacer width=20 height=1>Vary the control variable over the following sequence of values: 2, 5, 8, 11, 14, 17, 20. <pre> for ( int j = 2; j <= 20; j += 3 ) </pre> 6. <spacer width=20 height=1>Vary the control variable over the following sequence of values: 99, 88, 77, 66, 55, 44, 33, 22, 11, 0. <pre> for ( int j = 99; j >= 0; j -= 11 ) </pre> </page> <page> The next two examples provide simple applications of the for structure. The program of <a href="^Code::c:s0p6"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.20</a> uses the for structure to sum all the even integers from 2 to 100. <spacer width=16 height=1>Note that the body of the for structure in <a href="^Code::c:s0p6"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.20</a> could actually be merged into the rightmost portion of the for header by using the comma operator as follows: <pre> for ( int number = 2; // initialization number <= 100; // continuation condition sum += number, number += 2) // total and increment ; </pre> The initialization sum = 0 could also be <a href="^Practice::c:s0p27"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>merged into the initialization section of the for. </page> <page> <a href="^Practice::c:s0p28"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>The next example computes compound interest using the for structure. Consider the following problem statement: <indent width=16>A person invests $1000.00 in a savings account yielding 5 percent interest. Assuming that all interest is left on deposit in the account, calculate and print the amount of money in the account at the end of each year for 10 years. Use the following formula for determining these amounts:</indent> <pre> a = p (1 + r) n </pre> <indent width=16>where</indent> <pre> p is the original amount invested (i.e., the principal), r is the annual interest rate, </pre> </page> <page> <pre> n is the number of years, and a is the amount on deposit at the end of the nth year. </pre> This problem involves a loop that performs the indicated calculation for each of the 10 years the money remains on deposit. The solution is shown in <a href="^Code::c:s0p7"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.21</a>. <spacer width=16 height=1>The for structure executes the body of the loop 10 times, varying a control variable from 1 to 10 in increments of 1. C++ does not include an exponentiation operator, so we use the standard library function pow for this purpose. The function pow( x, y ) calculates the value of x raised to the yth power. Function pow takes two arguments of type double and </page> <page> returns a double value. The type double is a floating- point type much like float, but a variable of type double can store a value of much greater magnitude with greater precision than float. Constants (like 1000.0 and .05 in <a href="^Code::c:s0p7"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.21</a>) are treated as being type double by C++. This program would not compile without the inclusion of math.h. Function pow requires two double arguments. Note that year is an integer. <a href="^Errors::c:s0p22"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>The math.h file includes information that tells the compiler to convert the value of year to a temporary double representation before calling the function. This information is contained in pow's function prototype. Function </page> <page> prototypes are explained in Chapter 3. We provide a summary of the pow function and other math library functions in Chapter 3. <spacer width=16 height=1>Notice that we declared the variables amount, principal, and rate to be of type double. We have done this for simplicity because we are dealing with fractional parts of dollars and we need a type that allows decimal points in its values. Unfortunately, this can cause trouble. Here is a simple explanation of what can go wrong when using float or double to represent dollar amounts (assuming printing is done with setprecision(2)): Two float dollar amounts stored in the machine could be 14.234 (which prints as 14.23) and </page> <page> 18.673 (which prints as 18.67). When these amounts are added, they produce the internal sum 32.907 which prints as 32.91. Thus your printout could appear as <pre> 14.23 + 18.67 ------- 32.91 </pre> but a person adding the individual numbers as printed would expect the sum 32.90! <a href="^Practice::c:s0p29"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>You have been warned! <spacer width=16 height=1>The output statement <pre> cout << setw( 4 ) << year << setiosflags( ios::fixed | ios::showpoint ) << setw( 21 ) << setprecision( 2 ) << amount << endl; </pre> </page> <page> prints the values of the variables year and amount with the formatting specified by the parameterized stream manipulators setw, setiosflags and setprecision. The call setw(4) specifies that the next value output is printed in a field width of 4, i.e., the value is printed with at least 4 character positions. If the value to be output is less than 4 character positions wide, the value is right justified in the field by default. If the value to be output is more than 4 character positions wide, the field width is extended to accommodate the entire value. The call setiosflags(ios::left) can be used to specify that values should be output left justified. </page> <page> The remainder of the formatting in the preceding output statement indicates that variable amount is printed as a fixed-point value with a decimal point (specified with setiosflags( ios::fixed | ios::showpoint )) right- justified in a field of 21 character positions (specified with setw( 21 )) and two digits of precision to the right of the decimal point (specified with setprecision( 2 )). We will discuss the powerful input/output formatting capabilities of C++ in detail in Chapter 11. <spacer width=16 height=1>Note that the calculation 1.0 + rate which appears as an argument to the pow function is contained in the body of the for statement. <a href="^Perform::c:s0p8"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>In fact, this calculation produces </page> <page> the same result each time through the loop, so <a href="^Perform::c:s0p7"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>repeating the calculation is wasteful. <spacer width=16 height=1>For fun, be sure to try our Peter Minuet problem in the chapter exercises. This problem demonstrates the wonders of compound interest. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The language does not include an exponentiation operator."> The C++ language includes an exponentiation operator. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The pow method is from the math library. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. A double can store a larger number with a much greater precision than a float."> A float can store a number with a much greater precision and magnitude than a double. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Floating point numbers are approximated on most systems."> Floating point numbers are represented exactly on most systems. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.16 The switch Multiple-Selection Structure"> <page> 2.16 The switch Multiple-Selection Structure<hr> We have discussed the if single-selection structure and the if/else double-selection structure. Occasionally, an algorithm will contain a series of decisions in which a variable or expression is tested separately for each of the constant integral values it may assume, and different actions are taken. C++ provides the switch multiple-selection structure to handle such decision making. <spacer width=16 height=1>The switch structure consists of a series of case labels, and an optional default case. The program in <a href="^Code::c:s0p8"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.22</a> </page> <page> uses switch to count the number of each different letter grade that students earned on an exam. <spacer width=20 height=1> In the program, the user enters letter grades for a class. Inside the while header, <pre> while ( ( grade = cin.get() ) != EOF) </pre> the parenthesized assignment ( grade = cin.get() ) is executed first. The cin.get() function reads one character from the keyboard and stores that character in integer variable grade. The dot notation used in cin.get() will be explained in Chapter 6, "Classes." Characters are normally stored in variables of type char. However, an important feature of C++ is that </page> <page> characters can be stored in any integer data type because they are represented as 1-byte integers in the computer. Thus, we can treat a character as either an integer or a character depending on its use. For example, the statement <pre> cout << "The character (" << 'a' << ") has the value " << static_cast< int > ( 'a' ) << endl; </pre> prints the character a and its integer value as follows <pre> The character (a) has the value 97 </pre> The integer 97 is the character's numerical representation in the computer. Many computers today use the ASCII (American Standard Code for </page> <page> Information Interchange) character set in which 97 represents the lowercase letter 'a'. A list of the ASCII characters and their decimal values is presented in the appendices. <spacer width=16 height=1>Assignment statements as a whole have the value that is assigned to the variable on the left side of the =. Thus, the value of the assignment grade = cin.get() is the same as the value returned by cin.get() and assigned to the variable grade. <spacer width=16 height=1>The fact that assignment statements have values can be useful for initializing several variables to the same value. For example, <pre> a = b = c = 0; </pre> </page> <page> first evaluates the assignment c = 0 (because the = operator associates from right to left). The variable b is then assigned the value of the assignment c = 0 (which is 0). Then, the variable a is assigned the value of the assignment b = (c = 0) (which is also 0). In the program, the value of the assignment grade = cin.get() is compared with the value of EOF (a symbol whose acronym stands for "end-of-file"). We use EOF (which normally has the value 1) as the sentinel value. The user types a system-dependent keystroke combination to mean "end-of-file," i.e., "I have no more data to enter." EOF is a symbolic integer constant defined in the <iostream.h> header file. If the value assigned to </page> <page> grade is equal <a href="^Portable::c:s0p5"><img src="bckgrnds/icons/port_ico.gif" align=sidebar></a>to EOF, the program terminates. We have chosen to represent characters in this program as ints <a href="^Portable::c:s0p3"><img src="bckgrnds/icons/port_ico.gif" align=sidebar></a>because EOF has an integer value (again, normally 1). <spacer width=16 height=1>On UNIX systems and many others, end-of-file is entered by typing the sequence <pre> <ctrl-d> </pre> on a line by itself. This notation means to simultaneously press both the ctrl key and the d key. On other systems such as Digital Equipment Corporation's VAX VMS or Microsoft Corporation's MS-DOS, end-of-file can be entered by typing <pre> <ctrl-z> </pre> </page> <page> The user enters grades at the keyboard. When the Enter (or Return) key is pressed, the characters are read by the cin.get() function one character at a time. If the character entered is not end-of-file, the switch structure is entered. The keyword switch is followed by the variable name grade in parentheses. This is called the controlling expression. The value of this expression is compared with each of the case labels. Assume the user has entered the letter C as a grade. C is automatically compared to each case in the switch. If a match occurs (case 'C':), the statements for that case are executed. For the letter C, cCount is incremented by 1, and the switch structure is exited immediately with the break </page> <page> statement. Note that unlike other control structures, it is not necessary to enclose a multistatement case in braces. <spacer width=16 height=1>The break statement causes program control to proceed with the first statement after the switch structure. The break statement is used because the cases in a switch statement would otherwise run together. If break is not used anywhere in a switch structure, then each time a match occurs in the structure, the statements for all the remaining cases will be executed. (This feature is sometimes useful when performing the same actions for several cases, as in the program of<a href="^Code::c:s0p8"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.22</a>.) If no </page> <page> match occurs, the default case is executed and an error message is printed. <spacer width=16 height=1>Each case can have one or more actions. The switch structure is different from all other structures in that braces are not required around multiple actions in a case of a switch. The general switch multiple-selection structure (using a break in each case) is flowcharted in <a href="^Illustration::c:s0p16"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.23</a>. <spacer width=16 height=1><a href="^Errors::c:s0p25"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>The flowchart makes it clear that each break statement at the end of a case <a href="^Errors::c:s0p23"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>causes control to immediately exit the switch structure. Again, note that (besides small circles and arrows) the flowchart contains only rectangle symbols and diamond symbols. Imagine, </page> <page> again, that the programmer has access to a deep bin of empty switch structures--as many as the programmer might need to stack and nest with other control structures to form a structured implementation of an <a href="^Practice::c:s0p33"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>algorithm's flow of control. And again, the rectangles and diamonds are then filled with actions and decisions <a href="^Practice::c:s0p32"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>appropriate to the algorithm. Nested control structures are common, but it is rare to find <a href="^Practice::c:s0p31"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>nested switch structures in a program. <spacer width=16 height=1>In the switch structure of <a href="^Code::c:s0p8"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.22</a>, lines 46-49 <pre> case '\n': case '\ ': case ' ': break; </pre> </page> <page> cause the program to skip newline, tab and blank characters. Reading characters one at a time can cause some problems. To have the program read the characters, they must be sent to the computer by pressing the Enter key on the keyboard. This places a newline character in the input after the character we wish to process. Often, this newline character must be specially processed to make the program work correctly. By including the preceding cases in our switch structure, we prevent the error message in the default case from being printed each time a <a href="^Errors::c:s0p26"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>newline, tab or space is encountered in the input. </page> <page> Note that several case labels listed together (such as case 'D': case 'd': in <a href="^Code::c:s0p8"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.22</a>) simply means that the same set of actions is to occur for each of the cases. <spacer width=16 height=1>When using the switch structure, remember that it can only be used for testing a constant integral expression, i.e., any combination of character constants and integer constants that evaluates to a constant integer value. A character constant is represented as the specific character in single quotes such as 'A'. An integer constant is simply an integer value. <spacer width=16 height=1>When we get to the part of the book on object-oriented programming, we will present a more elegant way to implement switch logic. We will use a technique called </page> <page> polymorphism to create programs that are often clearer, more concise, easier to maintain, and easier to extend than programs using switch logic. <spacer width=16 height=1>Portable languages like C++ must have flexible data type sizes. Different applications may need integers of different sizes. C++ provides several data types to represent integers. The range of integer values for each type depends on the particular computer's hardware. In addition to the types int and char, C++ provides the types short (an abbreviation of short int) and long (an abbreviation of long int). The minimum range of values for short integers is +/-<a href="^Portable::c:s0p6"><img src="bckgrnds/icons/port_ico.gif" align=sidebar></a>32767. For the vast majority of integer calculations, long integers are sufficient. The </page> <page> minimum range of values for long integers is +/- 2147483647. <a href="^Perform::c:s0p11"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>On most computers, ints are equivalent either to short or to long. The range of values for an int is <a href="^Perform::c:s0p10"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>at least the same as the range for short integers and no larger than the range for long integers. The data type char can be used to represent any of the characters in the computer's character set. <a href="^Errors::c:s0p27"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>The data type char can also be used to represent small integers. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. Only constant integral expressions can be used with the switch structure."> The switch structure can be used with any data type. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The break statement is optional."> The break statement is required in a switch structure. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The break statement causes program control to proceed with the first statement after the switch structure. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The default case is optional. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.17 The do/while Repetition Structure"> <page> 2.17 The do/while Repetition Structure<hr> The do/while repetition structure is similar to the while structure. In the while structure, the loop-continuation condition is tested at the beginning of the loop before the body of the loop is performed. The do/while structure tests the loop-continuation condition after the loop body is performed; therefore, the loop body will be executed at least once. When a do/while terminates, execution continues with the statement after the while clause. Note that it is not necessary to use braces in the do/while structure if there is only one statement in the body. However, the braces are usually included to avoid </page> <page> confusion between the while and do/while structures. For example, <pre> while ( condition ) </pre> is normally regarded as the header to a while structure. A do/while with no braces around the single statement body appears as <pre> do statement while ( condition ); </pre> which can be confusing. The last line--while( condition );--may be misinterpreted by the reader as a while structure containing an empty statement. Thus, </page> <page> the do/while with one statement is often written as <a href="^Errors::c:s0p28"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>follows to avoid confusion: <pre> do { statement } while ( condition ); </pre> <a href="^Practice::c:s0p35"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>The program in <a href="^Code::c:s0p9"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.24</a> uses a do/while repetition structure to print the numbers from 1 to 10. Note that the control variable counter is preincremented in the loop-continuation test. Note also the use of the braces to enclose the single-statement body of the do/while structure. The do/while structure is flowcharted in <a href="^Illustration::c:s0p17"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.25</a>. This flowchart makes it clear that the loop-continuation </page> <page> condition is not executed until after the action is performed at least once. Again, note that (besides small circles and arrows) the flowchart contains only a rectangle symbol and a diamond symbol. Imagine, again, that the programmer has access to a deep bin of empty do/while structures--as many as the programmer might need to stack and nest with other control structures to form a structured implementation of an algorithm's flow of control. And again, the rectangles and diamonds are then filled with actions and decisions appropriate to the algorithm. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The body is executed at least once."> The body of a do/while is executed only if the loop-continuation condition is true. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The do/while structure ends in a semicolon. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.18 The break and continue Statements"> <page> 2.18 The break and continue Statements<hr> The break and continue statements alter the flow of control. The break statement, when executed in a while, for, do/while, or switch structure, causes immediate exit from that structure. Program execution continues with the first statement after the structure. Common uses of the break statement are to escape early from a loop, or to skip the remainder of a switch structure (as in <a href="^Code::c:s0p8"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.22</a>). <a href="^Code::c:s0p10"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 2.26</a> demonstrates the break statement in a for repetition structure. When the if structure detects that x has become 5, break is executed. This terminates the for statement and the </page> <page> program continues with the cout after the for. The loop fully executes only four times. <spacer width=16 height=1>Note that the control variable x in this program is defined outside the for structure header. This is because we intend to use the control variable both in the body of the loop and after the loop completes its execution. <spacer width=16 height=1>The continue statement, when executed in a while, for, or do/while structure, skips the remaining statements in the body of that structure, and proceeds with the next iteration of the loop. In while and do/while structures, the loop-continuation test is evaluated immediately after the continue statement is executed. In the for structure, the increment expression is executed, then the </page> <page> loop-continuation test is evaluated. Earlier, we stated that the while structure could be used in most cases to represent the for structure. The one exception occurs when the increment expression in the while structure follows the continue <a href="^Practice::c:s0p37"><img src="bckgrnds/icons/gpp_ico.gif" align=sidebar></a>statement. In this case, the increment is not executed before the repetition- continuation condition is tested, and the while does not execute in the same manner as the for. <a href="^Code::c:s0p11"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Figure 2.27</a> uses the continue <a href="^Perform::c:s0p12"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>statement in a for structure to skip the output statement in the structure and begin the next iteration of <a href="^Engineer::c:s0p16"><img src="bckgrnds/icons/seo_ico.gif" align=sidebar></a>the loop. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The continue statement skips the remaining iteration of a loop. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. The break statement can also be used to exit a switch structure."> The break statement can only be used to exit a repetition structure. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.19 Logical Operators"> <page> 2.19 Logical Operators<hr> So far we have studied only simple conditions such as counter <= 10, total > 1000, and number != sentinelValue. We have expressed these conditions in terms of the relational operators >, <, >=, and <=, and the equality operators == and !=. Each decision tested precisely one condition. To test multiple conditions while making a decision, we performed these tests in separate statements or in nested if or if/else structures. <spacer width=16 height=1>C++ provides logical operators that are used to form more complex conditions by combining simple conditions. The logical operators are && (logical </page> <page> AND), || (logical OR), and ! (logical NOT also called logical negation). We consider examples of each of these. <spacer width=16 height=1>Suppose we wish to ensure that two conditions are both true before we choose a certain path of execution. In this case we can use the logical && operator as follows: <pre> if ( gender == 1 && age >= 65 ) ++seniorFemales; </pre> This if statement contains two simple conditions. The condition gender == 1 might be evaluated, for example, to determine if a person is a female. The condition age >= 65 is evaluated to determine if a </page> <page> person is a senior citizen. The simple condition to the left of the && operator is evaluated first because the precedence of == is higher than the precedence of &&. If necessary, the simple condition to the right of the && operator is evaluated next because the precedence of >= is higher than the precedence of && (as we will discuss shortly, the right side of a logical AND expression is only evaluated if the left side is true). The if statement then considers the combined condition <pre> gender == 1 && age >= 65 </pre> This condition is true if and only if both of the simple conditions are true. Finally, if this combined condition is indeed true, then the count of seniorFemales is </page> <page> incremented by 1. If either or both of the simple conditions are false, then the program skips the incrementing and proceeds to the statement following the if. <a href="^Errors::c:s0p30"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>The preceding combined condition can be made more readable by adding redundant parentheses <pre> ( gender == 1 ) && ( age >= 65 ) </pre> The table of <a href="^Illustration::c:s0p18"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.28</a> summarizes the && operator. The table shows all four possible combinations of false and true values for expression1 and expression2. Such tables are often called truth tables. C++ evaluates to false or true all <a href="^Portable::c:s0p7"><img src="bckgrnds/icons/port_ico.gif" align=sidebar></a>expressions that include relational operators, equality operators, and/or logical operators. </page> <page> Now let us consider the || (logical OR) operator. Suppose we wish to ensure at some point in a program that either or both of two conditions are true before we choose a certain path of execution. In this case we use the || operator as in the following program segment: <pre> if ( semesterAverage >= 90 || finalExam >= 90 ) cout << "Student grade is A" << endl; </pre> This preceding condition also contains two simple conditions. The simple condition semesterAverage >= 90 is evaluated to determine if the student deserves an "A" in the course because of a solid performance throughout the semester. The simple condition finalExam >= 90 is evaluated to determine if the </page> <page> student deserves an "A" in the course because of an outstanding performance on the final exam. The if statement then considers the combined condition <pre> semesterAverage >= 90 || finalExam >= 90 </pre> and awards the student an "A" if either or both of the simple conditions are true. Note that the message "Student grade is A" is not printed only when both of the simple conditions are false. <a href="^Illustration::c:s0p19"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.29</a> is a truth table for the logical OR operator (||). <spacer width=16 height=1>The && operator has a higher precedence than the || operator. Both operators associate from left to right. An expression containing && or || <a href="^Perform::c:s0p13"><img src="bckgrnds/icons/perf_ico.gif" align=sidebar></a>operators is evaluated </page> <page> only until truth or falsehood is known. Thus, evaluation of the expression <pre> gender == 1 && age >= 65 </pre> will <a href="^Errors::c:s0p31"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>stop immediately if gender is not equal to 1 (i.e., the entire expression is false), and continue if gender is equal to 1 (i.e., the entire expression could still be true if the condition age >= 65 is true). C++ provides the ! (logical negation) operator to enable a programmer to "reverse" the meaning of a condition. Unlike the && and || operators, which combine two conditions (binary operators), the logical negation operator has only a single condition as an operand (unary operator). The logical negation operator is </page> <page> placed before a condition when we are interested in choosing a path of execution if the original condition (without the logical negation operator) is false, such as in the following program segment: <pre> if ( !( grade == sentinelValue ) ) cout << "The next grade is " << grade << endl; </pre> The parentheses around the condition grade == sentinelValue are needed because the logical negation operator has a higher precedence than the equality operator. <a href="^Illustration::c:s0p20"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.30</a> is a truth table for the logical negation operator. <spacer width=16 height=1>In most cases, the programmer can avoid using logical negation by expressing the condition differently with an </page> <page> appropriate relational or equality operator. For example, the preceding statement may also be written as follows: <pre> if ( grade != sentinelValue ) cout << "The next grade is " << grade << endl; </pre> This flexibility can often help a programmer express a condition in a more "natural" or convenient manner. <spacer width=16 height=1><a href="^Illustration::c:s0p21"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.31</a> shows the precedence and associativity of the C++ operators introduced to this point. The operators are shown from top to bottom in decreasing order of precedence. </page> <page> Drag the correct term to the box associated with the attribute: <component type="drag" width=16 height=18 label="&&" name="&&"> <component type="drag" width=8 height=18 label="!" name="!"> <component type="drag" width=16 height=18 label="||" name="||"> Logical AND.<component type="drop" width=24 height=18 name="&&"> Logical Negation.<component type="drop" width=24 height=18 name="!"> Logical OR.<component type="drop" width=24 height=18 name="||"> <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.20 Confusing Equality (==) and Assignment (=) Operators"> <page> 2.20 Confusing Equality (<tt>==</tt>) and Assignment (<tt>=</tt>) Operators<hr> There is one type of error that C++ programmers, no matter how experienced, tend to make so frequently that we felt it was worth a separate section. That error is accidentally swapping the operators == (equality) and = (assignment). What makes these swaps so damaging is the fact that they do not ordinarily cause syntax errors. Rather, statements with these errors ordinarily compile correctly, and the programs run to completion probably generating incorrect results through run-time logic errors. </page> <page> There are two aspects of C++ that cause these problems. One is that any expression that produces a value can be used in the decision portion of any control structure. If the value is 0, it is treated as false, and if the value is nonzero, it is treated as true. The second is that C++ assignments produce a value, namely the value that is assigned to the variable on the left side of the <a href="^Errors::c:s0p33"><img src="bckgrnds/icons/cpe_ico.gif" align=sidebar></a>assignment operator. For example, suppose we intend to write <pre> if ( payCode == 4 ) cout << "You get a bonus!" << endl; </pre> but we accidentally write </page> <page> <pre> if ( payCode = 4 ) cout << "You get a bonus!" << endl; </pre> The first if statement properly awards a bonus to the person whose paycode is equal to 4. The second if statement--the one with the error--evaluates the assignment expression in the if condition to the constant 4. Because any nonzero value is interpreted as true, the condition in this if statement is always true, and the person always receives a bonus regardless of what the actual paycode is! Even worse, the paycode has been modified when it was only <a href="^Debug::c:s0p0"><img src="bckgrnds/icons/dbt_ico.gif" align=sidebar></a>supposed to be examined! <spacer width=16 height=1>Variable names are said to be lvalues (for "left values") because they can be used on the left side of an </page> <page> assignment operator. Constants are said to be rvalues (for "right values") because they can be used on only the right side of an assignment operator. Note that lvalues can also be used as rvalues, but not vice versa. <spacer width=16 height=1>The other side of the coin can be equally unpleasant. Suppose the programmer wants to assign a value to a variable with a simple statement like <pre> x = 1; </pre> but instead writes <pre> x == 1; </pre> Here, too, this is not a syntax error. Rather the compiler simply evaluates the conditional expression. If x is </page> <page> equal to 1, the condition is true and the expression returns the value true. If x is not equal to 1, the condition is false and the expression returns the value false. Regardless of what value is returned, there is no <a href="^Debug::c:s0p3"><img src="bckgrnds/icons/dbt_ico.gif" align=sidebar></a>assignment operator, so the value is simply lost, and the value of x remains unaltered, probably causing an execution-time logic error. Unfortunately, we do not have a handy trick available to help you with this problem! </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The left side of an assignment expression is called an lvalue. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Either = or == may be used in a C++ condition. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.21 Structured Programming Summary"> <page> 2.21 Structured Programming Summary<hr> Just as architects design buildings by employing the collective wisdom of their profession, so should programmers design programs. Our field is younger than architecture is, and our collective wisdom is considerably sparser. We have learned that structured programming produces programs that are easier than unstructured programs to understand and hence are easier to test, debug, modify, and even prove correct in a mathematical sense. <spacer width=16 height=1> <a href="^Illustration::c:s0p22"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.32</a> summarizes C++'s control structures. Small circles are used in the figure to indicate the single </page> <page> entry point and the single exit point of each structure. Connecting individual flowchart symbols arbitrarily can lead to unstructured programs. Therefore, the programming profession has chosen to combine flowchart symbols to form a limited set of control structures, and to build structured programs by properly combining control structures in two simple ways. For simplicity, only single-entry/single-exit control structures are used--there is only one way to enter and only one way to exit each control structure. Connecting control structures in sequence to form structured programs is simple--the exit point of one control structure is connected to the entry point of the next </page> <page> control structure, i.e., the control structures are simply placed one after another in a program; we have called this "control structure stacking." The rules for forming structured programs also allow for control structures to be nested. <spacer width=16 height=1><a href="^Illustration::c:s0p26"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.33</a> shows the rules for forming properly structured programs. The rules assume that the rectangle flowchart symbol may be used to indicate any action including input/output. <spacer width=16 height=1>Applying the rules of <a href="^Illustration::c:s0p26"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.33</a> always results in a structured flowchart with a neat, building-block appearance. For example, repeatedly applying rule 2 to the simplest flowchart results in a structured flowchart </page> <page> containing many rectangles in sequence ( <a href="^Illustration::c:s0p24"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.35</a>). Notice that rule 2 generates a stack of control structures; so let us call rule 2 the stacking rule. <spacer width=16 height=1>Rule 3 is called the nesting rule. Repeatedly applying rule 3 to the simplest flowchart results in a flowchart with neatly nested control structures. For example, in <a href="^Illustration::c:s0p29"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.36</a>, the rectangle in the simplest flowchart is first replaced with a double-selection (if/else) structure. Then rule 3 is applied again to both of the rectangles in the double-selection structure, replacing each of these rectangles with double-selection structures. The dashed boxes around each of the double-selection structures </page> <page> represent the rectangle that was replaced in the original simplest flowchart. <spacer width=16 height=1>Rule 4 generates larger, more involved, and more deeply nested structures. The flowcharts that emerge from applying the rules in <a href="^Illustration::c:s0p26"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.33</a> constitute the set of all possible structured flowcharts and hence the set of all possible structured programs. <spacer width=16 height=1>The beauty of the structured approach is that we use only seven simple single-entry/single-exit pieces, and we assemble them in only two simple ways. <a href="^Illustration::c:s0p28"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Figure 2.37</a> shows the kinds of stacked building blocks that emerge from applying rule 2 and the kinds of nested building blocks that emerge from applying rule 3. The </page> <page> figure also shows the kind of overlapped building blocks that cannot appear in structured flowcharts (because of the elimination of the goto statement). <spacer width=16 height=1>If the rules in <a href="^Illustration::c:s0p26"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.33</a> are followed, an unstructured flowchart (such as that in <a href="^Illustration::c:s0p27"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.38</a>) cannot be created. If you are uncertain if a particular flowchart is structured, apply the rules of <a href="^Illustration::c:s0p26"><img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.33</a> in reverse to try to reduce the flowchart to the simplest flowchart. If the flowchart is reducible to the simplest flowchart, the original flowchart is structured; otherwise, it is not. <spacer width=16 height=1>Structured programming promotes simplicity. Bohm and Jacopini have given us the result that only three forms of control are needed: </page> <page> <indent width=8 delay>* Sequence</indent> <indent width=8 delay>* Selection</indent> <indent width=8 delay>* Repetition</indent> Sequence is trivial. Selection is implemented in one of three ways: <indent width=8 delay>* if structure (single selection)</indent> <indent width=8 delay>* if/else structure (double selection)</indent> <indent width=8 delay>* switch structure (multiple selection)</indent> In fact, it is straightforward to prove that the simple if structure is sufficient to provide any form of selection--everything that can be done with the if/else structure and the switch structure can be implemented </page> <page> by combining if structures (although perhaps not as smoothly). Repetition is implemented in one of three ways: <indent width=8 delay>* while structure</indent> <indent width=8 delay>* do/while structure</indent> <indent width=8 delay>* for structure</indent> It is straightforward to prove that the while structure is sufficient to provide any form of repetition. Everything that can be done with the do/while structure and the for structure can be done with the while structure (although perhaps not as smoothly). </page> <page> Combining these results illustrates that any form of control ever needed in a C++ program can be expressed in terms of: <indent width=8 delay>* sequence</indent> <indent width=8 delay>* if structure (selection)</indent> <indent width=8 delay>* while structure (repetition)</indent> And these control structures can be combined in only two ways--stacking and nesting. Indeed, structured programming promotes simplicity. <spacer width=16 height=1>In this chapter, we discussed how to compose programs from control structures containing actions and decisions. In Chapter 3, we introduce another program structuring unit called the function. We will learn to </page> <page> compose large programs by combining functions that, in turn, are composed of control structures. We will also discuss how functions promote software reusability. In Chapter 6, we introduce C++'s other program structuring unit called the class. We will then create objects from classes and proceed with our treatment of object-oriented programming. Now, we continue our introduction to objects by introducing a problem that the reader will attack with the techniques of object- oriented design. </page> <page> Select the true statement(s). <component type="checkbox" width=20 height=18 label="" name="" correct="True."> C++ uses only single-entry/single-exit control structures. <component type="checkbox" width=20 height=18 label="" name="" feedback="False. C++ has 7 control structures."> C++ has 10 control structures. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> The three forms of control are sequence, selection, and repetition. <component type="checkbox" width=20 height=18 label="" name="" correct="True."> Control structures can only be combined in two waysstacking and nesting. <component type=button name=b label="Check Your Answer" width=125 height=24> </page> </section> <section type=Body name=Default title="2.22 Thinking About Objects: Identifying the Objects in a Problem"> <page> 2.22 Thinking About Objects: Identifying the Objects in a Problem<hr> Here you are, new at C++ and wondering what this marvelous new technology called object-orientation is all about. These special sections at the ends of the next several chapters will ease you into object-orientation by means of an interesting and challenging real-world case study on building an elevator simulator. <spacer width=16 height=1>In Chapters 2 through 5, you will perform the various steps of an object-oriented design (OOD). Beginning in Chapter 6, you will implement the elevator simulator using the techniques of object-oriented programming </page> <page> (OOP) in C++. For now, this assignment may seem a bit complex. Please do not be concerned. You will attempt only a small portion of the problem in this chapter. Problem Statement A company intends to build a two-story office building and equip it with the "latest" elevator technology. The company wants you to develop an object-oriented software simulator that models the operation of the elevator to determine if this elevator will meet their needs. <spacer width=16 height=1>The elevator, which has a capacity of one person, is designed to conserve energy, so it only moves when necessary. The elevator starts the day waiting with its </page> <page> door shut on floor 1 of the building. The elevator, of course, alternates directions--first up, then down. <spacer width=16 height=1>Your simulator includes a clock that begins the day set to time 0 and that "ticks" once per second. The "scheduler" component of the simulator randomly schedules the arrival of the first person on each floor (you will learn how to schedule random arrivals in Chapter 3). When the clock's time becomes equal to the time of the first arrival, the simulator "creates" a new person for the specified floor, and places the person on that floor. The person then presses the button on that floor to summon the elevator. The person's destination </page> <page> floor is never equal to the floor on which that person arrives. <spacer width=16 height=1>If the first person of the day arrives at floor 1, the person can immediately get on the elevator (after pressing the button and waiting for the elevator's door to open, of course!). If the first person arrives at floor 2, the elevator proceeds to floor 2 to pick up that person. The elevator requires five ticks of the clock to travel between floors. <spacer width=16 height=1>The elevator signals its arrival at a floor by turning on a light above the elevator door on that floor and by sounding a bell inside the elevator. The button on the floor and the button in the elevator for that floor are </page> <page> reset, the elevator opens its door, the passenger--if there is one whose destination is that floor--gets out of the elevator, another passenger--if there is one waiting on that floor--gets into the elevator and presses a destination button, and the elevator closes its door. If the elevator needs to begin moving, it determines in which direction it should go (a simple decision on a two-story elevator!), and begins moving to the next floor. For simplicity, assume that all of the events that happen once the elevator reaches a floor, and until the elevator closes its doors on that floor, take zero time. The elevator always knows what floor it is on and what floor it is going to. </page> <page> At most, one person can be waiting on each floor at any time, so if a floor is occupied when a new person (i.e., not a person already on the elevator) is due to arrive at that floor, the new arrival is rescheduled for one second later. Assume that people arrive at random on each floor every 5 to 20 seconds--in Chapter 3 you will learn how to use random number generation to simulate this arrival rate. <spacer width=16 height=1>Your goal (over these special sections in Chapters 2 through 8) is to implement a working software simulator program that runs according to these specifications. Your program should simulate several minutes of the elevator's operation and determine if the </page> <page> elevator will successfully meet the anticipated traffic requirements in this office building. </page> </section> <section type=Body name=Default title="2.23 Elevator Laboratory Assignment 1"> <page> 2.23 Elevator Laboratory Assignment 1<hr> In this and the next few assignments, you will perform the separate steps of an object-oriented design. The first step is to identify the objects in your problem. You will eventually describe these objects in a formal way and implement them in C++. For this assignment, all you should do is <spacer width=16 height=1>1. Identify the objects in this elevator simulation problem. The problem statement specifies many objects working together to simulate the elevator and its interactions with the various people, floors of the building, buttons, etc. Locate the nouns from the </page> <page> problem statement; with high likelihood, these represent most of the objects necessary to implement the elevator simulation. <spacer width=16 height=1>2. For each object you identify, write one precisely worded paragraph that captures all the facts about that object from the problem statement. Notes 1. This is a good team exercise. Ideally you should work in a group of two to four people. This will help you and your teammates reinforce one another's efforts, and challenge and refine each other's design and implementation approaches. </page> <page> 2. Your group should compete with other groups in your class to develop the "best" design and implementation. <spacer width=16 height=1>3. You will learn how to implement "randomness" in the next chapter where we study random number generation. Random number generation helps you do things like simulate coin tossing and dice rolling. It will also help you simulate people arriving at random to use the elevator. <spacer width=16 height=1>4. We have made a number of simplifying assumptions. You may decide to supply additional details. <spacer width=16 height=1>5. Because the real world is so object oriented, it will be quite natural for you to pursue this project even though you have not yet formally studied object orientation. </page> <page> 6. Do not worry about perfection. System design is not a perfect and complete process, so you should pursue this project only on a best-efforts basis. Questions 1. How might you decide if the elevator is able to handle the anticipated traffic volume? 2. Why is it so much more complicated to implement a three-story (or larger) building? 3. We will see later that once we have created one elevator object, it is easy to create as many as we want. What problems do you foresee in having several elevators, each of which may pick up and discharge passengers at every floor in the building? </page> <page> 4. For simplicity, we have given our elevator and each floor a capacity of one passenger. What problems do you foresee in being able to increase these capacities? </page> </section> <section type=Body name=Default title="2.24 Summary"> <page> 2.24 Summary<hr> <indent width=8 delay>* A procedure for solving a problem in terms of the actions to be executed and the order in which these actions should be executed is called an algorithm. </indent> <indent width=8 delay>* Specifying the order in which statements are to be executed in a computer program is called program control. </indent> <indent width=8 delay>* Pseudocode helps the programmer "think out" a program before attempting to write it in a programming language such as C++.</indent> <indent width=8 delay>* Declarations are messages to the compiler telling it the names and attributes of variables and telling it to </indent> </page> <page> <indent width=8 delay>* reserve space for variables.</indent> <indent width=8 delay>* A selection structure is used to choose among alternative courses of action. </indent> <indent width=8 delay>* The if selection structure executes an indicated action only when the condition is true. </indent> <indent width=8 delay>* The if/else selection structure specifies separate actions to be executed when the condition is true and when the condition is false. </indent> <indent width=8 delay>* Whenever more than one statement is to be executed where normally only a single statement is expected, these statements must be enclosed in braces forming a compound statement. A compound statement can be placed anywhere a single statement can be placed. </indent> </page> <page> <indent width=8 delay>* An empty statement indicating that no action is to be taken is indicated by placing a semicolon (;) where a statement would normally be.</indent> <indent width=8 delay>* A repetition structure specifies that an action is to be repeated while some condition remains true. </indent> <indent width=8 delay>* The format for the while repetition structure is </indent> <pre> while ( condition ) statement </pre> <indent width=8 delay>* A value that contains a fractional part is referred to as a floating-point number and is represented by the data type float.</indent> <indent width=8 delay>* The unary cast operator static_cast< float >() creates a temporary floating-point copy of its operand. </indent> </page> <page> <indent width=8 delay>* C++ provides the arithmetic assignment operators +=, -=, *=, /=, and %= that help abbreviate certain common types of expressions. </indent> <indent width=8 delay>* C++ provides the increment (++) and decrement (--) operators to increment or decrement a variable by 1. If the operator is prefixed to the variable, the variable is incremented or decremented by 1 first, then used in its expression. If the operator is postfixed to the variable, the variable is used in its expression, then incremented or decremented by 1.</indent> <indent width=8 delay>* A loop is a group of instructions the computer executes repeatedly until some terminating condition is satisfied. Two forms of repetition are counter-controlled </indent> </page> <page> <indent width=8 delay>* repetition and sentinel-controlled repetition.</indent> <indent width=8 delay>* A loop counter is used to count repetitions for a group of instructions. It is incremented (or decremented) usually by 1 each time the group of instructions is performed. </indent> <indent width=8 delay>* Sentinel values are generally used to control repetition when the precise number of repetitions is not known in advance and the loop includes statements that obtain data each time the loop is performed. A sentinel value is entered after all valid data items have been supplied to the program. Sentinels should be different from valid data items.</indent> <indent width=8 delay>* The for repetition structure handles all the details of </indent> </page> <page> <indent width=8 delay>* counter-controlled repetition. The general format of the for structure is </indent> <pre> for ( expression1; expression2; expression3 ) statement </pre> where expression1 initializes the loop's control variable, expression2 is the loop-continuation condition, and expression3 increments the control variable. <indent width=8 delay>* The do/while repetition structure tests the loop-continuation condition at the end of the loop, so the body of the loop will be executed at least once. The format for the do/while structure is</indent> </page> <page> <pre> do statement while ( condition ); </pre> <indent width=8 delay>* The break statement, when executed in one of the repetition structures (for, while, and do/while), causes immediate exit from the structure. </indent> <indent width=8 delay>* The continue statement, when executed in one of the repetition structures (for, while, and do/while), skips any remaining statements in the body of the structure, and proceeds with the next iteration of the loop.</indent> <indent width=8 delay>* The switch statement handles a series of decisions in which a particular variable or expression is tested for values it may assume, and different actions are taken. In </indent> </page> <page> <indent width=8 delay>* most programs, it is necessary to include a break statement after the statements for each case. Several cases can execute the same statements by listing the case labels together before the statements. The switch structure can only test constant integral expressions. It is not necessary to enclose a multistatement case in braces.</indent> <indent width=8 delay>* On UNIX systems and many others, end-of-file is entered by typing the sequence</indent> <pre> <ctrl-d> </pre> on a line by itself. On VMS and DOS, end-of-file is entered by typing <pre> <ctrl-z> </pre> </page> <page> <indent width=8 delay>* Logical operators may be used to form complex conditions by combining conditions. The logical operators are &&, ||, and !, meaning logical AND, logical OR, and logical NOT (negation), respectively.</indent> <indent width=8 delay>* A true value is any nonzero value; a false value is 0 (zero).</indent> </page> </section> <section type=Popup name=Debug title="Testing"> <page> Programmers normally write conditions such as x == 7 with the variable name on the left and the constant on the right. By reversing these so that the constant is on the left and the variable name is on the right as in 7 == x, the </page> <page> programmer who accidentally replaces the == operator with = will be protected by the compiler. The compiler will treat this as a syntax error because only a variable name can be placed on the left-hand side of an </page> <page> assignment statement. At least this will prevent the potential devastation of a run- time logic error. </page> <page> Use your text editor to search for all occurrences of = in your program and check that you have the correct operator in each place. </page> </section> <section type=Popup name=Terminology title="Terminology"> <page> Symbols ! (logical negation operator) <a href="%s19p6"><img src=iicons/bullbib.gif></a> ! (logical NOT) <a href="%s19p1"><img src=iicons/bullbib.gif></a> && (logical AND operator) <a href="%s19p0"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p31"><img src=iicons/bullbib.gif></a> ++ operator <a href="%s12p1"><img src=iicons/bullbib.gif></a> ++ unary increment operator <a href="%s12p0"><img src=iicons/bullbib.gif></a> -- unary decrement operator <a href="%s12p0"><img src=iicons/bullbib.gif></a> ?: (ternary conditional operator) <a href="%s6p3"><img src=iicons/bullbib.gif></a> </page> <page> || (logical OR operator) <a href="%s19p1"><img src=iicons/bullbib.gif></a> <a href="%s19p4"><img src=iicons/bullbib.gif></a> <a href="%s19p6"><img src=iicons/bullbib.gif></a> A action <a href="%s6p2"><img src=iicons/bullbib.gif></a> <a href="%s6p4"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p5"><img src=iicons/bullbib.gif></a> <a href="%s21p8"><img src=iicons/bullbib.gif></a> action/decision model of computing <a href="%s6p2"><img src=iicons/bullbib.gif></a> algorithm <a href="%s2p0"><img src=iicons/bullbib.gif></a> <a href="%s5p4"><img src=iicons/bullbib.gif></a> <a href="%s6p2"><img src=iicons/bullbib.gif></a> <a href="%s8p0"><img src=iicons/bullbib.gif></a> <a href="^Engineer::c:s0p7"><img src=iicons/bullbib.gif></a> <a href="^Engineer::c:s0p11"><img src=iicons/bullbib.gif></a> ASCII (American Standard Code for Information Interchange) <a href="%s16p2"><img src=iicons/bullbib.gif></a> B </page> <page> body of the loop <a href="%s14p2"><img src=iicons/bullbib.gif></a> <a href=""><img src=iicons/bullbib.gif></a> break <a href="%s18p0"><img src=iicons/bullbib.gif></a> <a href="^Practice::c:s0p37"><img src=iicons/bullbib.gif></a> C case label <a href="%s16p0"><img src=iicons/bullbib.gif></a> <a href="%s16p6"><img src=iicons/bullbib.gif></a> cast operator <a href="%s9p10"><img src=iicons/bullbib.gif></a> <a href="%s9p13"><img src=iicons/bullbib.gif></a> <a href="%s9p14"><img src=iicons/bullbib.gif></a> char <a href="%s16p1"><img src=iicons/bullbib.gif></a> cin.get() <a href="%s16p1"><img src=iicons/bullbib.gif></a> <a href="%s16p3"><img src=iicons/bullbib.gif></a> <a href="%s16p6"><img src=iicons/bullbib.gif></a> compound statement <a href="%s6p9"><img src=iicons/bullbib.gif></a> <a href="%s7p1"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p1"><img src=iicons/bullbib.gif></a> <a href="%s9p10"><img src=iicons/bullbib.gif></a> conditional operator (?:) <a href="%s6p3"><img src=iicons/bullbib.gif></a> </page> <page> continue <a href="^Practice::c:s0p37"><img src=iicons/bullbib.gif></a> control structure <a href="%s4p2"><img src=iicons/bullbib.gif></a> counter-controlled repetition <a href="%s8p1"><img src=iicons/bullbib.gif></a> <a href="%s13p0"><img src=iicons/bullbib.gif></a> <a href="%s14p0"><img src=iicons/bullbib.gif></a> D decision <a href="%s5p4"><img src=iicons/bullbib.gif></a> <a href="%s6p2"><img src=iicons/bullbib.gif></a> <a href="%s21p8"><img src=iicons/bullbib.gif></a> decrement operator <a href="^Illustration::c:s0p12"><img src=iicons/bullbib.gif></a> default case <a href="%s16p0"><img src=iicons/bullbib.gif></a> <a href="%s16p8"><img src=iicons/bullbib.gif></a> <a href="%s16p10"><img src=iicons/bullbib.gif></a> definite repetition <a href="%s8p1"><img src=iicons/bullbib.gif></a> definition <a href="%s13p1"><img src=iicons/bullbib.gif></a> delay loop <a href="^Engineer::c:s0p14"><img src=iicons/bullbib.gif></a> do/while repetition structure <a href="%s17p0"><img src=iicons/bullbib.gif></a> </page> <page> double <a href="%s15p5"><img src=iicons/bullbib.gif></a> double-selection structure <a href="%s4p6"><img src=iicons/bullbib.gif></a> <a href="%s10p6"><img src=iicons/bullbib.gif></a> <a href="%s16p0"><img src=iicons/bullbib.gif></a> E empty statement <a href="^Engineer::c:s0p3"><img src=iicons/bullbib.gif></a> EOF <a href="%s16p1"><img src=iicons/bullbib.gif></a> <a href="%s16p4"><img src=iicons/bullbib.gif></a> F fatal error <a href="^Errors::c:s0p11"><img src=iicons/bullbib.gif></a> fixed-point format <a href="%s9p17"><img src=iicons/bullbib.gif></a> float <a href="%s9p11"><img src=iicons/bullbib.gif></a> for repetition structure <a href="%s14p0"><img src=iicons/bullbib.gif></a> G "garbage" value <a href="%s8p3"><img src=iicons/bullbib.gif></a> </page> <page> I if selection structure <a href="%s4p6"><img src=iicons/bullbib.gif></a> <a href="%s6p0"><img src=iicons/bullbib.gif></a> <a href="%s6p9"><img src=iicons/bullbib.gif></a> increment operator <a href="^Illustration::c:s0p12"><img src=iicons/bullbib.gif></a> indefinite repetition <a href="%s9p1"><img src=iicons/bullbib.gif></a> infinite loop <a href="^Errors::c:s0p5"><img src=iicons/bullbib.gif></a> <a href="%s9p11"><img src=iicons/bullbib.gif></a> <a href="%s14p5"><img src=iicons/bullbib.gif></a> <a href=""><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p28"><img src=iicons/bullbib.gif></a> initialization phase <a href="^Engineer::c:s0p5"><img src=iicons/bullbib.gif></a> integer division <a href="%s9p12"><img src=iicons/bullbib.gif></a> ios::fixed <a href="%s9p16"><img src=iicons/bullbib.gif></a> <a href="%s15p7"><img src=iicons/bullbib.gif></a> ios::showpoint <a href="%s9p16"><img src=iicons/bullbib.gif></a> <a href="%s15p7"><img src=iicons/bullbib.gif></a> K keyword <a href="^Errors::c:s0p3"><img src=iicons/bullbib.gif></a> L </page> <page> logic error <a href="^Errors::c:s0p7"><img src=iicons/bullbib.gif></a> logical AND <a href="%s19p0"><img src=iicons/bullbib.gif></a> logical negation <a href="%s19p1"><img src=iicons/bullbib.gif></a> logical operators <a href="%s19p0"><img src=iicons/bullbib.gif></a> logical OR <a href="%s19p1"><img src=iicons/bullbib.gif></a> long <a href="%s16p12"><img src=iicons/bullbib.gif></a> loop counter <a href="^Errors::c:s0p8"><img src=iicons/bullbib.gif></a> <a href="%s13p0"><img src=iicons/bullbib.gif></a> loop-continuation condition <a href="%s13p2"><img src=iicons/bullbib.gif></a> <a href="%s14p0"><img src=iicons/bullbib.gif></a> <a href="%s17p0"><img src=iicons/bullbib.gif></a> <a href="%s17p2"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p20"><img src=iicons/bullbib.gif></a> lvalue <a href="%s12p4"><img src=iicons/bullbib.gif></a> <a href="%s20p2"><img src=iicons/bullbib.gif></a> M multiple selection <a href="%s21p6"><img src=iicons/bullbib.gif></a> </page> <page> multiple-selection structure <a href="%s4p7"><img src=iicons/bullbib.gif></a> <a href="%s16p0"><img src=iicons/bullbib.gif></a> N nested control structures <a href="%s21p3"><img src=iicons/bullbib.gif></a> O off-by-one error <a href="^Errors::c:s0p9"><img src=iicons/bullbib.gif></a> <a href="%s14p2"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p15"><img src=iicons/bullbib.gif></a> P parameterized stream manipulator <a href="%s9p16"><img src=iicons/bullbib.gif></a> postdecrement operator <a href="%s12p0"><img src=iicons/bullbib.gif></a> </page> <page> postincrement <a href="%s12p0"><img src=iicons/bullbib.gif></a> <a href="%s12p3"><img src=iicons/bullbib.gif></a> pow function <a href="%s15p9"><img src=iicons/bullbib.gif></a> predecrement operator <a href="%s12p0"><img src=iicons/bullbib.gif></a> preincrement <a href="%s12p0"><img src=iicons/bullbib.gif></a> <a href="%s12p3"><img src=iicons/bullbib.gif></a> pseudocode <a href="%s3p0"><img src=iicons/bullbib.gif></a> <a href="%s4p3"><img src=iicons/bullbib.gif></a> <a href="%s8p1"><img src=iicons/bullbib.gif></a> <a href="%s10p4"><img src=iicons/bullbib.gif></a> <a href="^Engineer::c:s0p12"><img src=iicons/bullbib.gif></a> R repetition <a href="%s4p8"><img src=iicons/bullbib.gif></a> <a href="%s21p6"><img src=iicons/bullbib.gif></a> <a href="%s21p7"><img src=iicons/bullbib.gif></a> <a href="%s21p8"><img src=iicons/bullbib.gif></a> repetition structure <a href="%s4p2"><img src=iicons/bullbib.gif></a> <a href="%s7p0"><img src=iicons/bullbib.gif></a> <a href="%s9p6"><img src=iicons/bullbib.gif></a> </page> <page> rvalue <a href="%s20p3"><img src=iicons/bullbib.gif></a> S selection <a href="%s4p7"><img src=iicons/bullbib.gif></a> <a href="%s21p6"><img src=iicons/bullbib.gif></a> <a href="%s21p8"><img src=iicons/bullbib.gif></a> sentinel value <a href="%s9p1"><img src=iicons/bullbib.gif></a> <a href="%s9p6"><img src=iicons/bullbib.gif></a> <a href="^Practice::c:s0p11"><img src=iicons/bullbib.gif></a> <a href="%s16p4"><img src=iicons/bullbib.gif></a> sequential execution <a href="%s4p0"><img src=iicons/bullbib.gif></a> setiosflags <a href="%s9p16"><img src=iicons/bullbib.gif></a> <a href="%s15p9"><img src=iicons/bullbib.gif></a> setprecision <a href="%s9p15"><img src=iicons/bullbib.gif></a> setw <a href="%s15p9"><img src=iicons/bullbib.gif></a> short <a href="%s16p12"><img src=iicons/bullbib.gif></a> single-entry/single-exit control structures <a href="%s4p8"><img src=iicons/bullbib.gif></a> <a href="%s21p1"><img src=iicons/bullbib.gif></a> </page> <page> single-selection structure <a href="%s4p6"><img src=iicons/bullbib.gif></a> <a href="%s16p0"><img src=iicons/bullbib.gif></a> stacking <a href="%s4p8"><img src=iicons/bullbib.gif></a> <a href="%s5p4"><img src=iicons/bullbib.gif></a> <a href="%s6p2"><img src=iicons/bullbib.gif></a> <a href="%s21p8"><img src=iicons/bullbib.gif></a> static_cast() <a href="^Illustration::c:s0p21"><img src=iicons/bullbib.gif></a> structured programming <a href="%s1p0"><img src=iicons/bullbib.gif></a> <a href="%s4p1"><img src=iicons/bullbib.gif></a> <a href="^Practice::c:s0p37"><img src=iicons/bullbib.gif></a> switch selection structure <a href="%s4p6"><img src=iicons/bullbib.gif></a> T ternary operator <a href="%s6p3"><img src=iicons/bullbib.gif></a> top-down, stepwise refinement <a href="%s9p0"><img src=iicons/bullbib.gif></a> <a href="%s9p2"><img src=iicons/bullbib.gif></a> <a href="%s10p0"><img src=iicons/bullbib.gif></a> transfer of control <a href="%s4p0"><img src=iicons/bullbib.gif></a> U </page> <page> unary operator <a href="%s9p14"><img src=iicons/bullbib.gif></a> <a href="%s19p6"><img src=iicons/bullbib.gif></a> W while repetition structure <a href="%s7p1"><img src=iicons/bullbib.gif></a> whitespace characters <a href="%s5p1"><img src=iicons/bullbib.gif></a> <a href="^Errors::c:s0p26"><img src=iicons/bullbib.gif></a> </page> </section> <section type=Popup name=Portable title="Portability"> <page> In the new C++ draft standard, the scope of the control variable declared in the initialization section of a for structure is different from the scope in older C++ compilers. C++ code created with old C++ compilers can </page> <page> break when compiled on compilers that are compatible with the C++ draft standard. These are two defensive programming strategies that can be used to prevent this problem: Either define control variables with </page> <page> different names in every for structure, or, if you prefer to use the same name for the control variable in several for structures, define the control variable outside and before the first for loop. </page> <page> Testing for the symbolic constant EOF rather than 1 makes programs more portable. The ANSI standard states that EOF is a negative integral value (but not necessarily 1). Thus, EOF could have </page> <page> different values on different systems. </page> <page> The keystroke combinations for entering end-of-file are system dependent. </page> <page> Because ints vary in size between systems, use long integers if you expect to process integers outside the range \xb1 32767 and you would like to be able to run the program on several different computer systems. </page> <page> For compatibility with earlier versions of the C++ standard, the bool value true can also be represented by any nonzero value and the bool value false can also be represented as the value 0. </page> </section> <section type=Popup name=Illustration title="Illustrations"> <page> <a href="^Illustration::c:s0p3">Fig. 2.1</a> Flowcharting C++'s sequence structure. <a href="^Illustration::c:s0p4">Fig. 2.2</a> C++ keywords. <a href="^Illustration::c:s0p5">Fig. 2.3</a> Flowcharting the single-selection if structure. <a href="^Illustration::c:s0p6">Fig. 2.4</a> Flowcharting the double-selection if/else structure. <a href="^Illustration::c:s0p7">Fig. 2.5</a> Flowcharting the while repetition structure. <a href="^Illustration::c:s0p8">Fig. 2.6</a> Pseudocode algorithm that uses counter-controlled repetition to solve the class average problem. <a href="^Code::c:s0p0">Fig. 2.7</a> C++ program and sample execution for the class average problem with counter- controlled repetition. <a href="^Illustration::c:s0p9">Fig. 2.8</a> Pseudocode algorithm that uses sentinel-controlled repetition to solve the class average problem. <a href="^Code::c:s0p1">Fig. 2.9</a> C++ program and sample execution for the class average problem with sentinel- controlled repetition. <a href="^Illustration::c:s0p10">Fig. 2.10</a> Pseudocode for examination results problem. <a href="^Code::c:s0p2">Fig. 2.11</a> C++ program and sample executions for examination results problem. <a href="^Illustration::c:s0p11">Fig. 2.12</a> Arithmetic assignment operators. <a href="^Illustration::c:s0p12">Fig. 2.13</a> The increment and decrement operators. <a href="^Code::c:s0p3">Fig. 2.14</a> The difference between preincrementing and postincrementing. <a href="^Illustration::c:s0p13">Fig. 2.15</a> Precedence of the operators encountered so far in the text. </page> <page> <a href="^Code::c:s0p4">Fig. 2.16</a> Counter-controlled repetition. <a href="^Code::c:s0p5">Fig. 2.17</a> Counter-controlled repetition with the for structure. <a href="^Illustration::c:s0p14">Fig. 2.18</a> Components of a typical for header. <a href="^Illustration::c:s0p15">Fig. 2.19</a> Flowcharting a typical for repetition structure. <a href="^Code::c:s0p6">Fig. 2.20</a> Summation with for. <a href="^Code::c:s0p7">Fig. 2.21</a> Calculating compound interest with for. <a href="^Code::c:s0p8">Fig. 2.22</a> An example using switch. <a href="^Illustration::c:s0p16">Fig. 2.23</a> The switch multiple-selection structure with breaks. <a href="^Code::c:s0p9">Fig. 2.24</a> Using the do/while structure. <a href="^Illustration::c:s0p17">Fig. 2.25</a> Flowcharting the do/while repetition structure. <a href="^Code::c:s0p10">Fig. 2.26</a> Using the break statement in a for structure. <a href="^Code::c:s0p11">Fig. 2.27</a> Using the continue statement in a for structure. <a href="^Illustration::c:s0p18">Fig. 2.28</a> Truth table for the && (logical AND) operator. <a href="^Illustration::c:s0p19">Fig. 2.29</a> Truth table for the || (logical OR) operator. <a href="^Illustration::c:s0p20">Fig. 2.30</a> Truth table for operator <tt>!</tt> (logical negation). <a href="^Illustration::c:s0p21">Fig. 2.31</a> Operator precedence and associativity. <a href="^Illustration::c:s0p22">Fig. 2.32</a> C++'s single-entry/single-exit sequence, selection, and repetition structures. <a href="^Illustration::c:s0p26">Fig. 2.33</a> Rules for forming structured programs. <a href="^Illustration::c:s0p25">Fig. 2.34</a> The simplest flowchart. </page> <page> <a href="^Illustration::c:s0p24">Fig. 2.35</a> Repeatedly applying rule 2 of Fig. 2.33 to the simplest flowchart. <a href="^Illustration::c:s0p29">Fig. 2.36</a> Applying rule 3 of Fig. 2.33 to the simplest flowchart. <a href="^Illustration::c:s0p28">Fig. 2.37</a> Stacked, nested, and overlapped building blocks. <a href="^Illustration::c:s0p27">Fig. 2.38</a> An unstructured flowchart. </page> <page> <a href="~audio/Ch02/02fig001.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.1 - Flowcharting C++'s sequence structure.<img src="graphics/ch02/fig02001.gif" > </page> <page> <a href="~audio/Ch02/02fig002.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.2 - C++ keywords.<img src="graphics/ch02/fig02002.gif" > </page> <page> <a href="~audio/Ch02/02fig003.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.3 - Flowcharting the single-selection if structure.<img src="graphics/ch02/fig02003.gif" > </page> <page> <a href="~audio/Ch02/02fig004.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.4 - Flowcharting the double-selection if/else structure.<img src="graphics/ch02/fig02004.gif" > </page> <page> <a href="~audio/Ch02/02fig005.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.5 - Flowcharting the while repetition structure.<img src="graphics/ch02/fig02005.gif" > </page> <page> <a href="~audio/Ch02/02fig006.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.6 - Pseudocode algorithm that uses counter-controlled repetition to solve the class average problem. <indent width=20>Set total to zero</indent> <indent width=20>Set grade counter to one</indent> <indent width=20></indent> <indent width=20>While grade counter is less than or equal to ten</indent> <indent width=20> Input the next grade</indent> <indent width=20> Add the grade into the total</indent> <indent width=20> Add one to the grade counter</indent> <indent width=20></indent> <indent width=20>Set the class average to the total divided by ten</indent> <indent width=20>Print the class average</indent> </page> <page> <a href="~audio/Ch02/02fig008.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.8 - Pseudocode algorithm that uses sentinel-controlled repetition to solve the class average problem. <indent width=20>Initialize total to zero</indent> <indent width=20>Initialize counter to zero</indent> <indent width=20>Input the first grade (possibly the sentinel)</indent> <indent width=20>While the user has not as yet entered the sentinel </indent> <indent width=20> Add this grade into the running total</indent> <indent width=20> Add one to the grade counter</indent> <indent width=20> Input the next grade (possibly the sentinel)</indent> <indent width=20>If the counter is not equal to zero</indent> <indent width=20> Set the average to the total divided by the counter</indent> <indent width=20> Print the average</indent> <indent width=20>else</indent> <indent width=20> Print "No grades were entered"</indent> </page> <page> <a href="~audio/Ch02/02fig010.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.10 - Pseudocode for examination results problem. <indent width=20>Initialize passes to zero</indent> <indent width=20>Initialize failures to zero</indent> <indent width=20>Initialize student counter to one</indent> <indent width=20></indent> <indent width=20>While student counter is less than or equal to ten</indent> <indent width=20><spacer width=20 height=1>Input the next exam result</indent> <indent width=20><spacer width=20 height=1>If the student passed</indent> <indent width=20><spacer width=20 height=1>Add one to passes</indent> <indent width=20>else</indent> <indent width=20><spacer width=20 height=1>Add one to failures</indent> <indent width=20><spacer width=20 height=1>Add one to student counter</indent> <indent width=20></indent> <indent width=20>Print the number of passes</indent> <indent width=20>Print the number of failures</indent> <indent width=20>If more than eight students passed </indent> <indent width=20><spacer width=20 height=1>Print "Raise tuition"</indent> </page> <page> <a href="~audio/Ch02/02fig012.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.12 - Arithmetic assignment operators.<img src="graphics/ch02/fig02012.gif" > </page> <page> <a href="~audio/Ch02/02fig013.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.13 - The increment and decrement operators.<img src="graphics/ch02/fig02013.gif" > </page> <page> <a href="~audio/Ch02/02fig015.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.15 - Precedence of the operators encountered so far in the text.<img src="graphics/ch02/fig02015.gif" > </page> <page> <a href="~audio/Ch02/02fig018.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.18 - Components of a typical for header.<img src="graphics/ch02/fig02018.gif" > </page> <page> <a href="~audio/Ch02/02fig019.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.19 - Flowcharting a typical for repetition structure.<img src="graphics/ch02/fig02019.gif" > </page> <page> <a href="~audio/Ch02/02fig023.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.23 - The switch multiple-selection structure with breaks.<img src="graphics/ch02/fig02023.gif" > </page> <page> <a href="~audio/Ch02/02fig025.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.25 - Flowcharting the do/while repetition structure.<img src="graphics/ch02/fig02025.gif" > </page> <page> <a href="~audio/Ch02/02fig028.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.28 - Truth table for the && (logical AND) operator.<img src="graphics/ch02/fig02028.gif" > </page> <page> Fig<a href="~audio/Ch02/02fig029.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>ure 2.29 - Truth table for the || (logical OR) operator.<img src="graphics/ch02/fig02029.gif" > </page> <page> Fig<a href="~audio/Ch02/02fig030.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>ure 2.30 - Truth table for operator ! (logical negation).<img src="graphics/ch02/fig02030.gif" > </page> <page> <a href="~audio/Ch02/02fig031.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.31 - Operator precedence and associativity.<img src="graphics/ch02/fig02031.gif" > </page> <page> <a href="~audio/Ch02/02fig032.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.32 - C++'s single-entry/single-exit sequence, selection, and repetition structures. (Part 1 of 2)<img src="graphics/ch02/fig0232a.gif" > </page> <page> <a href="~audio/Ch02/02fig032.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.32 - C++'s single-entry/single-exit sequence, selection, and repetition structures. (Part 2 of 2)<img src="graphics/ch02/fig0232b.gif" > </page> <page> <a href="~audio/Ch02/02fig035.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.35 - Repeatedly applying rule 2 of <a href="^Illustration::c:s0p26"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.33</a> to the simplest flowchart. <img src="graphics/ch02/fig02035.gif" > </page> <page> <a href="~audio/Ch02/02fig034.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.34 - The simplest flowchart.<img src="graphics/ch02/fig02034.gif" > </page> <page> <a href="~audio/Ch02/02fig033.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.33 - Rules for forming structured programs.<img src="graphics/ch02/fig02033.gif" > </page> <page> <a href="~audio/Ch02/02fig038.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.38 - An unstructured flowchart.<img src="graphics/ch02/fig02038.gif" > </page> <page> <a href="~audio/Ch02/02fig037.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.37 - Stacked, nested, and overlapped buildig blocks.<img src="graphics/ch02/fig02037.gif" > </page> <page> <a href="~audio/Ch02/02fig036.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.36 - Applying rule 3 of <a href="^Illustration::c:s0p26"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.33</a> to the simplest flowchart. (Part 1 of 2) <img src="graphics/ch02/fig0236a.gif" > </page> <page> <a href="~audio/Ch02/02fig036.au"><img src="bckgrnds/icons/audio.gif" align=sidebar></a>Figure 2.36 - Applying rule 3 of <a href="^Illustration::c:s0p26"> <img src="bckgrnds/icons/ill_ico.gif" align=sidebar>Fig. 2.33</a> to the simplest flowchart. (Part 2 of 2) <img src="graphics/ch02/fig0236b.gif" > </page> </section> <section type=Popup name=Objective title="Objectives"> <page> <indent width=8 delay>* To understand basic problem solving techniques.</indent> <indent width=8 delay>* To be able to develop algorithms through the process of top-down, stepwise refinement.</indent> <indent width=8 delay>* To be able to use the if, if/else, and switch selection structures to choose among alternative actions.</indent> <foreign name="audio" url="~audio/Ch02/02obj.au"> </page> <page> <indent width=8 delay>* To be able to use the while, do/while, and for repetition structures to execute statements in a program repeatedly.</indent> <indent width=8 delay>* To understand counter-controlled repetition and sentinel-controlled repetition.</indent> <indent width=8 delay>* To be able to use the increment, decrement, assignment, and logical operators.</indent> </page> <page> <indent width=8 delay>* To be able to use the break and continue program control statements.</indent> </page> </section> <section type=Popup name=Practice title="Good Practices"> <page> Consistently applying reasonable indentation conventions throughout your programs greatly improves program readability. We suggest a fixed-size tab of about 1/4 inch or three blanks per indent. </page> <page> Pseudocode is often used to "think out" a program during the program design process. Then the pseudocode program is converted to C++. </page> <page> If there are several levels of indentation, each level should be indented the same additional amount of space. </page> <page> Indent both body statements of an if/else structure. </page> <page> Always putting the braces in an <tt>if/else</tt> structure (or any control structure) helps prevent their accidental omission, especially when adding statements to an if or else clause at a later time. </page> <page> Some programmers prefer to type the beginning and ending braces of compound statements before typing the individual statements within the braces. This helps avoid omitting one or both of the braces. </page> <page> Initialize counters and totals. </page> <page> Declare each variable on a separate line. </page> <page> When performing division by an expression whose value could be zero, explicitly test for this case and handle it appropriately in your program (such as printing an error message) rather than </page> <page> allowing the fatal error to occur. </page> <page> In a sentinel-controlled loop, the prompts requesting data entry should explicitly remind the user what the sentinel value is. </page> <page> Prompt the user for each keyboard input. The prompt should indicate the form of the input and any special input values (such as the sentinel value the user should enter to terminate a loop). </page> <page> Do not compare floating-point values for equality or inequality. Rather, test that the absolute value of the difference is less than a specified small value. </page> <page> Initializing variables when they are declared helps the programmer avoid the problems of uninitialized data. </page> <page> Unary operators should be placed next to their operands with no intervening spaces. </page> <page> Control counting loops with integer values. </page> <page> Indent the statements in the body of each control structure. </page> <page> Put a blank line before and after each control structure to make it stand out in the program. </page> <page> Too many levels of nesting can make a program difficult to understand. As a general rule, try to avoid using more than three levels of indentation. </page> <page> Vertical spacing above and below control structures, and indentation of the bodies of control structures within the control structure headers gives programs a two-dimensional </page> <page> appearance that greatly improves readability. </page> <page> Using the final value in the condition of a while or for structure and using the <= relational operator will help avoid off-by-one errors. For a loop used to print the values 1 to 10, for example, the loop- continuation condition </page> <page> should be counter <= 10 rather than counter < 10 (which is an off- by-one error) or counter < 11 (which is nevertheless correct). Many programmers nevertheless prefer so- called zero-based counting in which to </page> <page> count 10 times through the loop, counter would be initialized to zero and the loop- continuation test would be counter < 10. </page> <page> Place only expressions involving the control variables in the initialization and increment sections of a for structure. Manipulations of other variables should appear either before the loop (if they execute only </page> <page> once like initialization statements) or in the loop body (if they execute once per repetition like incrementing or decrementing statements). </page> <page> Although the value of the control variable can be changed in the body of a for loop, avoid doing so because this practice can lead to subtle logic errors. </page> <page> Although statements preceding a for and statements in the body of a for can often be merged into the for header, avoid doing so because it can make the program more difficult to read. </page> <page> Limit the size of control structure headers to a single line if possible. </page> <page> Do not use variables of type float or double to perform monetary calculations. The imprecision of floating- point numbers can cause errors that will result in incorrect monetary values. In the exercises, we explore </page> <page> the use of integers to perform monetary calculations. Note: C++ class libraries are becoming available for properly performing monetary calculations. </page> <page> In a switch structure when the default clause is listed last, the break statement is not required. Some programmers include this break for clarity and symmetry with other cases. </page> <page> Although the case clauses and the default case clause in a switch structure can occur in any order, it is considered a good programming practice to place the default clause last. </page> <page> Provide a default case in switch statements. Cases not explicitly tested in a switch statement without a default case are ignored. Including a default case focuses the programmer on the need to process </page> <page> exceptional conditions. There are situations in which no default processing is needed. </page> <page> Some programmers always include braces in a do/while structure even if the braces are not necessary. This helps eliminate ambiguity between the while structure and the do/while structure </page> <page> containing one statement. </page> <page> Some programmers feel that break and continue violate structured programming. Because the effects of these statements can be achieved by structured programming techniques we will soon </page> <page> learn, these programmers do not use break and continue. </page> </section> <section type=Popup name=Perform title="Performance"> <page> In a nested if/else structure, test the conditions that are more likely to be true at the beginning of the nested if/else structure. This will enable the nested if/else structure to run faster and exit earlier than testing </page> <page> infrequently occurring cases. </page> <page> A nested if/else structure can be much faster than a series of single selection if structures because of the possibility of early exit after one of the conditions is satisfied. </page> <page> Programmers can write programs a bit faster and compilers can compile programs a bit faster when the "abbreviated" assignment operators are used. Some compilers generate code that runs faster </page> <page> when "abbreviated" assignment operators are used. </page> <page> Many of the performance tips we mention in this text result in nominal improvements, so the reader may be tempted to ignore them. Significant performance improvement is often </page> <page> realized when a supposedly nominal improvement is placed in a loop that may repeat many times. </page> <page> Many compilers contain optimization features that improve the code you write, but it is still better to write good code from the start. </page> <page> Avoid placing expressions whose values do not change inside loops. But even if you do, many of today's sophisticated optimizing compilers will automatically place such expressions outside loops in the </page> <page> generated machine language code. </page> <page> Using smaller integer sizes may result in a slower program if the machine's instructions for manipulating them are not as efficient as for the natural size integers (e.g., sign extension must be done on them). </page> <page> In performance- oriented situations where memory is at a premium or execution speed is crucial, it may be desirable to use smaller integer sizes. </page> <page> The break and continue statements, when used properly, perform faster than the corresponding structured techniques we will soon learn. </page> <page> An expressions using operator &&, if the separate conditions are independent of one another make the condition that is most likely to be false the leftmost condition. In expressions using operator ||, make the </page> <page> condition that is most likely to be true the leftmost condition. This can reduce a program's execution time. </page> </section> <section type=Popup name=Code title="Code Examples"> <page> Figure 2.7 C++ program and sample execution for the class average problem with counter-controlled repetition. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_07.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_07.jar"> <foreign name="audio" url="~audio/Ch02/02fig007.au"> <foreign name="execute" url="!jarexe Run/fig02_07.jar"> </page> <page> Figure 2.9 - C++ program and sample execution for the class average problem with sentinel-controlled repetition. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_09.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_09.jar"> <foreign name="audio" url="~audio/Ch02/02fig009.au"> <foreign name="execute" url="!jarexe Run/fig02_09.jar"> </page> <page> Figure 2.11 C++ program and sample executions for examination results problem. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_011.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_11.jar"> <foreign name="audio" url="~audio/Ch02/02fig011.au"> <foreign name="execute" url="!jarexe Run/fig02_11.jar"> </page> <page> Figure 2.14 The difference between preincrementing and postincrementing. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_014.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_14.jar"> <foreign name="audio" url="~audio/Ch02/02fig014.au"> <foreign name="execute" url="!jarexe Run/fig02_14.jar"> </page> <page> Figure 2.16 Counter-controlled repetition. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_016.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_16.jar"> <foreign name="audio" url="~audio/Ch02/02fig016.au"> <foreign name="execute" url="!jarexe Run/fig02_16.jar"> </page> <page> Figure 2.17 Counter-controlled repetition with the for structure. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_017.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_17.jar"> <foreign name="audio" url="~audio/Ch02/02fig017.au"> <foreign name="execute" url="!jarexe Run/fig02_17.jar"> </page> <page> Figure 2.20 Summation with for. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_020.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_20.jar"> <foreign name="audio" url="~audio/Ch02/02fig020.au"> <foreign name="execute" url="!jarexe Run/fig02_20.jar"> </page> <page> Figure 2.21 Calculating compound interest with for. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_021.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_21.jar"> <foreign name="audio" url="~audio/Ch02/02fig021.au"> <foreign name="execute" url="!jarexe Run/fig02_21.jar"> </page> <page> Figure 2.22 An example using switch. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_022.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_22.jar"> <foreign name="audio" url="~audio/ch02/02fig022.au"> <foreign name="execute" url="!jarexe Run/fig02_22.jar"> </page> <page> Figure 2.24 Using the do/while structure. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_024.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_24.jar"> <foreign name="audio" url="~audio/Ch02/02fig024.au"> <foreign name="execute" url="!jarexe Run/fig02_24.jar"> </page> <page> Figure 2.26 Using the break statement in a for structure. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_026.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_26.jar"> <foreign name="audio" url="~audio/Ch02/02fig026.au"> <foreign name="execute" url="!jarexe Run/fig02_26.jar"> </page> <page> Figure 2.27 Using the continue statement in a for structure. <applet code=gsl.win.helper.TextBox width=580 height=300> <param name="file" value="code/ch02/fig02_027.txt"> </applet> <foreign name="copy2disk" url="!jcpy Source/fig02_27.jar"> <foreign name="audio" url="~audio/Ch02/02fig027.au"> <foreign name="execute" url="!jarexe Run/fig02_27.jar"> </page> </section> <section type=Popup name=Exercises title="Exercises"> <page pagename="Exercise 2.1"> Exercise 2.1 Exercises 2.1 through 2.10 correspond to Sections 2.1 through 2.12. Exercises 2.11 through 2.13 correspond to Sections 2.13 through 2.21. Answer each of the following questions. a) All programs can be written in terms of three types of control structures: _______, ________, and ________. b) The ________selection structure is used to execute one action when a condition is true and another action when that condition is false. c) Repetition of a set of instructions a specific number of times is called _______ repetition. <foreign name="answers" url="^Answers::c:s0p0"> </page> <page pagename="Exercise 2.1"> d) When it is not known in advance how many times a set of statements will be repeated, a________value can be used to terminate the repetition. <foreign name="answers" url="^Answers::c:s0p0"> </page> <page pagename="Exercise 2.2"> Exercise 2.2 Write four different C++ statements that each add 1 to integer variable x. <foreign name="answers" url="^Answers::c:s0p1"> </page> <page pagename="Exercise 2.3"> Exercise 2.3 Write C++ statements to accomplish each of the following: a) Assign the sum of x and y to z and increment the value of x by 1 after the calculation. b) Test if the value of the variable count is greater than 10. If it is, print "Count is greater than 10." c) Decrement the variable x by 1 then subtract it from the variable total. d) Calculate the remainder after q is divided by divisor and assign the result to q. Write this statement two different ways. <foreign name="answers" url="^Answers::c:s0p2"> </page> <page pagename="Exercise 2.4"> Exercise 2.4 Write a C++ statement to accomplish each of the following tasks. a) Declare variables sum and x to be of type int. b) Initialize variable x to 1. c) Initialize variable sum to 0. d) Add variable x to variable sum and assign the result to variable sum. e) Print "The sum is: " followed by the value of variable sum. <foreign name="answers" url="^Answers::c:s0p3"> </page> <page pagename="Exercise 2.5"> Exercise 2.5 Combine the statements that you wrote in<a href="^Exercises::c:s0p4"> <img src="bckgrnds/icons/exercise.gif" align=sidebar>Exercise 2.4</a> into a program that calculates and prints the sum of the integers from 1 to 10. Use the while structure to loop through the calculation and increment statements. The loop should terminate when the value of x becomes 11. <foreign name="answers" url="^Answers::c:s0p4"> </page> <page pagename="Exercise 2.6"> Exercise 2.6 Determine the values of each variable after the calculation is performed. Assume that when each statement begins executing all variables have the integer value 5. <pre> a) product *= x++; b) quotient /= ++x; </pre> <foreign name="answers" url="^Answers::c:s0p6"> </page> <page pagename="Exercise 2.7"> Exercise 2.7 Write single C++ statements that a) Input integer variable x with cin and >>. b) Input integer variable y with cin and >>. c) Initialize integer variable i to 1. d) Initialize integer variable power to 1. e) Multiply variable power by x and assign the result to power. f) Increment variable y by 1. g) Test y to see if it is less than or equal to x. h) Output integer variable power with cout and <<. <foreign name="answers" url="^Answers::c:s0p7"> </page> <page pagename="Exercise 2.8"> Exercise 2.8 Write a C++ program that uses the statements in <a href="^Exercises::c:s0p7"> <img src="bckgrnds/icons/exercise.gif" align=sidebar>Exercise 2.7</a> to calculate x raised to the y power. The program should have a while repetition control structure. <foreign name="answers" url="^Answers::c:s0p8"> </page> <page pagename="Exercise 2.9"> Exercise 2.9 Identify and correct the errors in each of the following: <pre> a) while ( c <= 5 ) { product *= c; ++c; b) cin << value; c) if ( gender == 1 ) cout << "Woman" << endl; else; cout << "Man" << endl; </pre> <foreign name="answers" url="^Answers::c:s0p10"> </page> <page pagename="Exercise 2.10"> Exercise 2.10 What is wrong with the following while repetition structure: <pre> while ( z >= 0 ) sum += z; </pre> <foreign name="answers" url="^Answers::c:s0p11"> </page> <page pagename="Exercise 2.11"> Exercise 2.11 State whether the following are true or false. If the answer is false, explain why. a) The default case is required in the switch selection structure. b) The break statement is required in the default case of a switch selection structure to exit the structure properly. c) The expression ( x > y && a is true if either the expression x > y is true or the expression a < b is true. d) An expression containing the || operator is true if either or both of its operands is true. <foreign name="answers" url="^Answers::c:s0p12"> </page> <page pagename="Exercise 2.12"> Exercise 2.12 Write a C++ statement or a set of C++ statements to accomplish each of the following: a) Sum the odd integers between 1 and 99 using a for structure. Assume the integer variables sum and count have been declared. b) Print the value 333.546372 in a field width of 15 characters with precisions of 1, 2, and 3. Print each number on the same line. Left justify each number in its field. What three values print? c) Calculate the value of 2.5 raised to the power of 3 using the pow function. Print the result with a precision of 2 in a field width of 10 positions. What prints? <foreign name="answers" url="^Answers::c:s0p13"> </page> <page pagename="Exercise 2.12"> d) Print the integers from 1 to 20 using a while loop and the counter variable x. Assume that the variable x has been declared, but not initialized. Print only 5 integers per line. Hint: Use the calculation x % 5. When the value of this is 0, print a newline character, otherwise print a tab character. e) Repeat Exercise 2.12 (d) using a for structure. <foreign name="answers" url="^Answers::c:s0p13"> </page> <page pagename="Exercise 2.13"> Exercise 2.13 Find the error in each of the following code segments and explain how to correct it. <pre> a) x = 1; while ( x <= 10 ); x++; } b) for ( y = .1; y != 1.0; y += .1 ) cout << y << endl; c) switch ( n ) { case 1: </pre> <foreign name="answers" url="^Answers::c:s0p17"> </page> <page pagename="Exercise 2.13"> <pre> cout << "The number is 1" << endl; </pre> <pre> case 2: cout << "The number is 2" << endl; break; default: cout << "The number is not 1 or 2" << endl; break; } </pre> d) The following code should print the values 1 to 10. <pre> n = 1; while ( n < 10 ) cout << n++ << endl; </pre> <foreign name="answers" url="^Answers::c:s0p17"> </page> <page pagename="Exercise 2.14"> Exercise 2.14 Exercises 2.14 through 2.38 correspond to Sections 2.1 through 2.12. Exercises 2.39 through 2.63 correspond to Sections 2.13 through 2.21. Identify and correct the errors in each of the following (Note: There may be more than one error in each piece of code): <pre> a) if ( age >= 65 ); cout << "Age is greater than or equal to 65" << endl; else cout << "Age is less than 65 << endl"; </pre> <foreign name="answers" url="^Answers::c:s0p19"> </page> <page pagename="Exercise 2.14"> <pre> b) if ( age >= 65 ) </pre> <pre> cout << "Age is greater than or equal to 65" << endl; else; cout << "Age is less than 65 << endl"; c) int x = 1, total; while ( x <= 10 ) { total += x; ++x; } d) While ( x <= 100 ) total += x; ++x; </pre> <foreign name="answers" url="^Answers::c:s0p19"> </page> <page pagename="Exercise 2.14"> <pre> e) while ( y > 0 ) { </pre> <pre> cout << y << endl; ++y; } </pre> <foreign name="answers" url="^Answers::c:s0p19"> </page> <page pagename="Exercise 2.15"> Exercise 2.15 What does the following program print? <pre> #include <iostream.h> int main() { int y, x = 1, total = 0; while (x <= 10) { y = x * x; cout << y << endl; total += y; ++x; } </pre> </page> <page pagename="Exercise 2.15"> <pre> cout << "Total is " << total << endl; </pre> <pre> return 0; } </pre> </page> <page pagename="Exercise 2.15"> For Exercises 2.16 to 2.19 perform each of these steps: a) Read the problem statement. b) Formulate the algorithm using pseudocode and top-down, stepwise refinement. c) Write a C++ program. d) Test, debug, and execute the C++ program. </page> <page pagename="Exercise 2.16"> Exercise 2.16 Drivers are concerned with the mileage obtained by their automobiles. One driver has kept track of several tankfuls of gasoline by recording miles driven and gallons used for each tankful. Develop a C++ program that will input the miles driven and gallons used for each tankful. The program should calculate and display the miles per gallon obtained for each tankful. After processing all input information, the program should calculate and print the combined miles per gallon obtained for all tankfuls. <hr> <pre> Enter the gallons used (-1 to end): 12.8 Enter the miles driven: 287 The miles / gallon for this tank was 22.421875 </pre> <foreign name="answers" url="^Answers::c:s0p23"> </page> <page pagename="Exercise 2.16"> <pre> Enter the gallons used (-1 to end): 10.3 </pre> <pre> Enter the miles driven: 200 The miles / gallon for this tank was 19.417475 Enter the gallons used (-1 to end): 5 Enter the miles driven: 120 The miles / gallon for this tank was 24.000000 Enter the gallons used (-1 to end): -1 The overall average miles/gallon was 21.601423 </pre> <hr> <foreign name="answers" url="^Answers::c:s0p23"> </page> <page pagename="Exercise 2.17"> Exercise 2.17 Develop a C++ program that will determine if a department store customer has exceeded the credit limit on a charge account. For each customer, the following facts are available: a) Account number (an integer) b) Balance at the beginning of the month c) Total of all items charged by this customer this month d) Total of all credits applied to this customer's account this month e) Allowed credit limit The program should input each of these facts, calculate the new balance (= beginning balance + charges - credits), and determine if the new balance exceeds the customer's credit limit. For those customers whose credit limit is exceeded, </page> <page pagename="Exercise 2.17"> the program should display the customer's account number, credit limit, new balance, and the message "Credit limit exceeded." <hr> <pre> Enter account number (-1 to end): 100 Enter beginning balance: 5394.78 Enter total charges: 1000.00 Enter total credits: 500.00 Enter credit limit: 5500.00 Account: 100 Credit limit: 5500.00 Balance: 5894.78 Credit Limit Exceeded. </pre> </page> <page pagename="Exercise 2.17"> <pre> Enter account number (-1 to end): 200 </pre> <pre> Enter beginning balance: 1000.00 Enter total charges: 123.45 Enter total credits: 321.00 Enter credit limit: 1500.00 Enter account number (-1 to end): 300 Enter beginning balance: 500.00 Enter total charges: 274.73 Enter total credits: 100.00 Enter credit limit: 800.00 Enter account number (-1 to end): -1 </pre> <hr> </page> <page pagename="Exercise 2.18"> Exercise 2.18 One large chemical company pays its salespeople on a commission basis. The salespeople receive $200 per week plus 9 percent of their gross sales for that week. For example, a salesperson who sells $5000 worth of chemicals in a week receives $200 plus 9 percent of $5000, or a total of $650. Develop a C++ program that will input each salesperson's gross sales for last week and calculate and display that salesperson's earnings. Process one salesperson's figures at a time. <hr> <pre> Enter sales in dollars (-1 to end): 5000.00 Salary is: $650.00 </pre> <foreign name="answers" url="^Answers::c:s0p24"> </page> <page pagename="Exercise 2.18"> <pre> Enter sales in dollars (-1 to end): 6000.00 </pre> <pre> Salary is: $740.00 Enter sales in dollars (-1 to end): 7000.00 Salary is: $830.00 Enter sales in dollars (-1 to end): -1 </pre> <hr> <foreign name="answers" url="^Answers::c:s0p24"> </page> <page pagename="Exercise 2.19"> Exercise 2.19 Develop a C++ program that will determine the gross pay for each of several employees. The company pays "straight-time" for the first 40 hours worked by each employee and pays "time-and-a-half" for all hours worked in excess of 40 hours. You are given a list of the employees of the company, the number of hours each employee worked last week, and the hourly rate of each employee. Your program should input this information for each employee, and should determine and display the employee's gross pay. <hr> <pre> Enter hours worked (-1 to end): 39 Enter hourly rate of the worker ($00.00): 10.00 Salary is $390.00 </pre> </page> <page pagename="Exercise 2.19"> <pre> Enter hours worked (-1 to end): 40 </pre> <pre> Enter hourly rate of the worker ($00.00): 10.00 Salary is $400.00 Enter hours worked (-1 to end): 41 Enter hourly rate of the worker ($00.00): 10.00 Salary is $415.00 Enter hours worked (-1 to end): -1 </pre> <hr> </page> <page pagename="Exercise 2.20"> Exercise 2.20 The process of finding the largest number (i.e., the maximum of a group of numbers) is used frequently in computer applications. For example, a program that determines the winner of a sales contest would input the number of units sold by each salesperson. The salesperson who sells the most units wins the contest. Write a pseudocode program and then a C++ program that inputs a series of 10 numbers, and determines and prints the largest of the numbers. Hint: Your program should use three variables as follows: counter: A counter to count to 10 (i.e., to keep track of how many numbers have been input, and to determine when all 10 numbers have been processed). number: The current number input to the program. largest: The largest number found so far. <foreign name="answers" url="^Answers::c:s0p25"> </page> <page pagename="Exercise 2.21"> Exercise 2.21 Write a C++ program that utilizes looping and the tab escape sequence \ to print the following table of values: <hr> <pre> N 10*N 100*N 1000*N<spacer width=20 height=1> 1 10 100 1000 2 20 200 2000 3 30 300 3000 4 40 400 4000 5 50 500 5000 </pre> <hr> </page> <page pagename="Exercise 2.22"> Exercise 2.22 Using an approach similar to<a href="^Exercises::c:s0p31"> <img src="bckgrnds/icons/exercise.gif" align=sidebar>Exercise 2.20</a>, find the two largest values of the 10 numbers. Note: You may input each number only once. </page> <page pagename="Exercise 2.23"> Exercise 2.23 Modify the program in <a href="^Code::c:s0p2"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.11</a> to validate its inputs. On any input, if the value entered is other than 1 or 2, keep looping until the user enters a correct value. </page> <page pagename="Exercise 2.24"> Exercise 2.24 What does the following program print? <pre> #include <iostream.h> int main() { int count = 1; while ( count <= 10 ) { cout << ( count % 2 ? "****" : "++++++++" ) << endl; ++count; } return 0; } </pre> <foreign name="answers" url="^Answers::c:s0p20"> </page> <page pagename="Exercise 2.25"> Exercise 2.25 What does the following program print? <pre> #include <iostream.h> int main() { int row = 10, column; while ( row >= 1 ) { column = 1; while ( column <= 10 ) { cout << ( row % 2 ? "<" : ">" ); ++column; } </pre> </page> <page pagename="Exercise 2.25"> <pre> --row; </pre> <pre> cout << endl; } return 0; } </pre> </page> <page pagename="Exercise 2.26"> Exercise 2.26 (Dangling Else Problem) Determine the output for each of the following when x is 9 and y is 11 and when x is 11 and y is 9. Note that the compiler ignores the indentation in a C++ program. Also, the C++ compiler always associates an else with the previous if unless told to do otherwise by the placement of braces {}. Because, on first glance, the programmer may not be sure which if an else matches, this is referred to as the "dangling else" problem. We have eliminated the indentation from the following code to make the problem more challenging. (Hint: Apply indentation conventions you have learned.) <pre> a) if ( x < 10 ) if ( y > 10 ) cout << "*****" << endl; </pre> <foreign name="answers" url="^Answers::c:s0p21"> </page> <page pagename="Exercise 2.26"> <pre> else </pre> <pre> cout << "#####" << endl; cout << "$$$$$" << endl; b) if ( x < 10 ) { if ( y > 10 ) cout << "*****" << endl; } else { cout << "#####" << endl; cout << "$$$$$" << endl; } </pre> <foreign name="answers" url="^Answers::c:s0p21"> </page> <page pagename="Exercise 2.27"> Exercise 2.27 (Another Dangling Else Problem) Modify the following code to produce the output shown. Use proper indentation techniques. You may not make any changes other than inserting braces. The compiler ignores indentation in a C++ program. We have eliminated the indentation from the following code to make the problem more challenging. Note: It is possible that no modification is necessary. <pre> if ( y == 8 ) if ( x == 5 ) cout << "@@@@@" << endl; else cout << "#####" << endl; </pre> </page> <page pagename="Exercise 2.27"> <pre> cout << "$$$$$" << endl; </pre> <pre> cout << "&&&&&" << endl; </pre> a) Assuming x = 5 and y = 8, the following output is produced. <hr> <pre> @@@@@ $$$$$ &&&&& </pre> <hr> b) Assuming x = 5 and y = 8, the following output is produced. <hr> <pre> @@@@@ </pre> <hr> </page> <page pagename="Exercise 2.27"> c) Assuming x = 5 and y = 8, the following output is produced. <hr> <pre> @@@@@ &&&&& </pre> <hr> d) Assuming x = 5 and y = 7, the following output is produced. Note: The last three output statements after the else are all part of a compound statement. <hr> <pre> ##### $$$$$ &&&&& </pre> <hr> </page> <page pagename="Exercise 2.28"> Exercise 2.28 Write a program that reads in the size of the side of a square and then prints a hollow square of that size out of asterisks and blanks. Your program should work for squares of all side sizes between 1 and 20. For example, if your program reads a size of 5, it should print <hr> <pre> ***** * * * * * * ***** </pre> <hr> </page> <page pagename="Exercise 2.29"> Exercise 2.29 A palindrome is a number or a text phrase that reads the same backwards as forwards. For example, each of the following five-digit integers are palindromes: 12321, 55555, 45554 and 11611. Write a program that reads in a five-digit integer and determines whether or not it is a palindrome. (Hint: Use the division and modulus operators to separate the number into its individual digits.) <foreign name="answers" url="^Answers::c:s0p26"> </page> <page pagename="Exercise 2.30"> Exercise 2.30 Input an integer containing only 0s and 1s (i.e., a "binary" integer) and print its decimal equivalent. (Hint: Use the modulus and division operators to pick off the "binary" number's digits one at a time from right to left. Just as in the decimal number system where the rightmost digit has a positional value of 1, and the next digit left has a positional value of 10, then 100, then 1000, etc., in the binary number system the rightmost digit has a positional value of 1, the next digit left has a positional value of 2, then 4, then 8, etc. Thus the decimal number 234 can be interpreted as 4 * 1 + 3 * 10 + 2 * 100. The decimal equivalent of binary 1101 is 1 * 1 + 0 * 2 + 1 * 4 + 1 * 8 or 1 + 0 + 4 + 8 or 13.) </page> <page pagename="Exercise 2.31"> Exercise 2.31 Write a program that displays the following checkerboard pattern <hr> <pre> * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * </pre> <hr> <foreign name="answers" url="^Answers::c:s0p27"> </page> <page pagename="Exercise 2.31"> Your program may use only three output statements, one of each of the following forms: <pre> cout << "* "; cout << ' '; cout << endl; </pre> <foreign name="answers" url="^Answers::c:s0p27"> </page> <page pagename="Exercise 2.32"> Exercise 2.32 Write a program that keeps printing the multiples of the integer 2, namely 2, 4, 8, 16, 32, 64, etc. Your loop should not terminate (i.e., you should create an infinite loop). What happens when you run this program? </page> <page pagename="Exercise 2.33"> Exercise 2.33 Write a program that reads the radius of a circle (as a float value) and computes and prints the diameter, the circumference, and the area. Use the value 3.14159 for pi. <foreign name="answers" url="^Answers::c:s0p28"> </page> <page pagename="Exercise 2.34"> Exercise 2.34 What's wrong with the following statement? Provide the correct statement to accomplish what the programmer was probably trying to do. <pre> cout << ++( x + y ); </pre> </page> <page pagename="Exercise 2.35"> Exercise 2.35 Write a program that reads three nonzero float values and determines and prints if they could represent the sides of a triangle. </page> <page pagename="Exercise 2.36"> Exercise 2.36 Write a program that reads three nonzero integers and determines and prints if they could be the sides of a right triangle. </page> <page pagename="Exercise 2.37"> Exercise 2.37 A company wants to transmit data over the telephone, but they are concerned that their phones may be tapped. All of their data is transmitted as four-digit integers. They have asked you to write a program that encrypts their data so that it may be transmitted more securely. Your program should read a four-digit integer and encrypt it as follows: Replace each digit by (the sum of that digit plus 7) modulus 10. Then, swap the first digit with the third, swap the second digit with the fourth, and print the encrypted integer. Write a separate program that inputs an encrypted four-digit integer, and decrypts it to form the original number. <foreign name="answers" url="^Answers::c:s0p29"> </page> <page pagename="Exercise 2.38"> Exercise 2.38 The factorial of a nonnegative integer n is written n! (pronounced "n factorial") and is defined as follows: n! = n x (n - 1) x (n - 2) x ... x 1 (for values of n greater than or equal to 1) and n! = 1 (for n = 0). For example, 5! = 5 x 4 x 3 x 2 x 1 which is 120. a) Write a program that reads a nonnegative integer and computes and prints its factorial. b) Write a program that estimates the value of the mathematical constant e by using the formula: </page> <page pagename="Exercise 2.38"> <img src="graphics/ch02/ex0238a.gif" > c) Write a program that computes the value of <img src="graphics/ch02/ex0238b.gif" > by using the formula <pre> <img src="graphics/ch02/ex0238c.gif" > </pre> </page> <page pagename="Exercise 2.39"> Exercise 2.39 Find the error in each of the following (Note: There may be more than one error): <pre> a) For ( x = 100, x >= 1, x++ ) cout << x << endl; </pre> b) The following code should print whether integer value is odd or even: <pre> switch ( value % 2 ) { case 0: cout << "Even integer" << endl; case 1: cout << "Odd integer" << endl; } </pre> </page> <page pagename="Exercise 2.39"> c) The following code should output the odd integers from 19 to 1: <pre> for ( x = 19; x >= 1; x += 2 ) cout << x << endl; </pre> d) The following code should output the even integers from 2 to 100: <pre> counter = 2; do { cout << counter << endl; counter += 2; } While ( counter < 100 ); </pre> </page> <page pagename="Exercise 2.40"> Exercise 2.40 Write a program that sums a sequence of integers. Assume that the first integer read specifies the number of values remaining to be entered. Your program should read only one value per input statement. A typical input sequence might be <pre> 5 100 200 300 400 500 </pre> where the 5 indicates that the subsequent 5 values are to be summed. <foreign name="answers" url="^Answers::c:s0p30"> </page> <page pagename="Exercise 2.41"> Exercise 2.41 Write a program that calculates and prints the average of several integers. Assume the last value read is the sentinel 9999. A typical input sequence might be <pre> 10 8 11 7 9 9999 </pre> indicating that the average of all the values preceding 9999 is to be calculated. </page> <page pagename="Exercise 2.42"> Exercise 2.42 What does the following program do? <pre> #include <iostream.h> int main() { int x, y; cout << "Enter two integers in the range 1-20: "; cin >> x >> y; for ( int i = 1; i <= y; i++ ) { for ( int j = 1; j <= x; j++ ) cout << '@'; cout << endl; </pre> </page> <page pagename="Exercise 2.42"> <pre> } </pre> <pre> return 0; } </pre> </page> <page pagename="Exercise 2.43"> Exercise 2.43 Write a program that finds the smallest of several integers. Assume that the first value read specifies the number of values remaining. <foreign name="answers" url="^Answers::c:s0p31"> </page> <page pagename="Exercise 2.44"> Exercise 2.44 Write a program that calculates and prints the product of the odd integers from 1 to 15. </page> <page pagename="Exercise 2.45"> Exercise 2.45 The factorial function is used frequently in probability problems. The factorial of a positive integer n (written n! and pronounced "n factorial") is equal to the product of the positive integers from 1 to n. Write a program that evaluates the factorials of the integers from 1 to 5. Print the results in tabular format. What difficulty might prevent you from calculating the factorial of 20? <foreign name="answers" url="^Answers::c:s0p32"> </page> <page pagename="Exercise 2.46"> Exercise 2.46 Modify the compound interest program of<a href="^Illustration::c:s0p13"> Section 2.15</a> to repeat its steps for interest rates of 5 percent, 6 percent, 7 percent, 8 percent, 9 percent, and 10 percent. Use a for loop to vary the interest rate. </page> <page pagename="Exercise 2.47"> Exercise 2.47 Write a program that prints the following patterns separately one below the other. Use for loops to generate the patterns. All asterisks (*) should be printed by a single statement of the form cout << '*'; (this causes the asterisks to print side by side). Hint: The last two patterns require that each line begin with an appropriate number of blanks. Extra credit: Combine your code from the four separate problems into a single program that prints all four patterns side by side making clever use of nested for loops. </page> <page pagename="Exercise 2.47"> <hr> <pre> (A) (B) (C) (D) * ********** ********** * ** ********* ********* ** *** ******** ******** *** **** ******* ******* **** ***** ****** ****** ***** ****** ***** ***** ****** ******* **** **** ******* ******** *** *** ******** ********* ** ** ********* ********** * * ********** </pre> <hr> </page> <page pagename="Exercise 2.48"> Exercise 2.48 One interesting application of computers is drawing graphs and bar charts (sometimes called "histograms"). Write a program that reads five numbers (each between 1 and 30). For each number read, your program should print a line containing that number of adjacent asterisks. For example, if your program reads the number seven, it should print *******. <foreign name="answers" url="^Answers::c:s0p33"> </page> <page pagename="Exercise 2.49"> Exercise 2.49 A mail order house sells five different products whose retail prices are product 1 -- $2.98, product 2--$4.50, product 3--$9.98, product 4--$4.49, and product 5--$6.87. Write a program that reads a series of pairs of numbers as follows: a) Product number b) Quantity sold for one day Your program should use a switch statement to help determine the retail price for each product. Your program should calculate and display the total retail value of all products sold last week. <foreign name="answers" url="^Answers::c:s0p34"> </page> <page pagename="Exercise 2.50"> Exercise 2.50 Modify the program of<a href="^Code::c:s0p8"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.22</a> so that it calculates the grade point average for the class. A grade of 'A' is worth 4 points, 'B' is worth 3 points, etc. </page> <page pagename="Exercise 2.51"> Exercise 2.51 Modify the program in <a href="^Code::c:s0p7"><img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.21</a> so it uses only integers to calculate the compound interest. (Hint: Treat all monetary amounts as integral numbers of pennies. Then "break" the result into its dollar portion and cents portion by using the division and modulus operations. Insert a period.) </page> <page pagename="Exercise 2.52"> Exercise 2.52 Assume i = 1, j = 2, k = 3, and m = 2. What does each of the following statements print? Are the parentheses necessary in each case? <pre> a) cout << ( i == 1 ) << endl; b) cout << ( j == 3 ) << endl; c) cout << ( i >= 1 && j < 4 ) << endl; d) cout << ( m <= 99 && k < m ) << endl; e) cout << ( j >= i || k == m ) << endl; f) cout << ( k + m < j || 3 - j >= k ) << endl; g) cout << ( !m ) << endl; h) cout << ( !( j - m ) ) << endl; i) cout << ( !( k > m ) ) << endl; </pre> </page> <page pagename="Exercise 2.53"> Exercise 2.53 Write a program that prints a table of the binary, octal, and hexadecimal equivalents of the decimal numbers in the range 1 through 256. If you are not familiar with these number systems, read Appendix E first. </page> <page pagename="Exercise 2.54"> Exercise 2.54 Calculate the value of pi from the infinite series <pre> <img src="graphics/ch02/ex0254a.gif" > </pre> Print a table that shows the value of pi approximated by 1 term of this series, by two terms, by three terms, etc. How many terms of this series do you have to use before you first get 3.14? 3.141? 3.1415? 3.14159? <foreign name="answers" url="^Answers::c:s0p35"> </page> <page pagename="Exercise 2.55"> Exercise 2.55 (Pythagorean Triples) A right triangle can have sides that are all integers. The set of three integer values for the sides of a right triangle is called a Pythagorean triple. These three sides must satisfy the relationship that the sum of the squares of two of the sides is equal to the square of the hypotenuse. Find all Pythagorean triples for side1, side2, and the hypotenuse all no larger than 500. Use a triple- nested for-loop that tries all possibilities. This is an example of "brute force" computing. You will learn in more advanced computer science courses that there are many interesting problems for which there is no known algorithmic approach other than using sheer brute force. </page> <page pagename="Exercise 2.56"> Exercise 2.56 A company pays its employees as managers (who receive a fixed weekly salary), hourly workers (who receive a fixed hourly wage for up to the first 40 hours they work and "time-and-a-half," i.e., 1.5 times their hourly wage, for overtime hours worked), commission workers (who receive $250 plus 5.7% of their gross weekly sales), or pieceworkers (who receive a fixed amount of money per item for each of the items they produce--each pieceworker in this company works on only one type of item). Write a program to compute the weekly pay for each employee. You do not know the number of employees in advance. Each type of employee has its own pay code: Managers have paycode 1, hourly workers have code 2, commission workers have code 3 and pieceworkers have code 4. Use a switch to compute each employee's pay based on that employee's paycode. </page> <page pagename="Exercise 2.56"> Within the switch, prompt the user (i.e., the payroll clerk) to enter the appropriate facts your program needs to calculate each employee's pay based on that employee's paycode. </page> <page pagename="Exercise 2.57"> Exercise 2.57 (De Morgan's Laws) In this chapter, we discussed the logical operators &&, ||, and !. De Morgan's Laws can sometimes make it more convenient for us to express a logical expression. These laws state that the expression !(condition1 && condition2) is logically equivalent to the expression (!condition1 || !condition2). Also, the expression !(condition1 || condition2) is logically equivalent to the expression (!condition1 && !condition2). Use De Morgan's Laws to write equivalent expressions for each of the following, and then write a program to show that both the original expression and the new expression in each case are equivalent: <pre> a) !( x < 5 ) && !( y >= 7 ) b) !( a == b ) || !( g != 5 ) </pre> </page> <page pagename="Exercise 2.57"> <pre> c) !( ( x <= 8 ) && ( y > 4 ) ) </pre> <pre> d) !( ( i > 4 ) || ( j <= 6 ) ) </pre> </page> <page pagename="Exercise 2.58"> Exercise 2.58 Write a program that prints the following diamond shape. You may use output statements that print either a single asterisk (*) or a single blank. Maximize your use of repetition (with nested for structures) and minimize the number of output statements. <hr> <pre> * *** ***** ******* ********* ******* </pre> <foreign name="answers" url="^Answers::c:s0p36"> </page> <page pagename="Exercise 2.58"> <pre> ***** </pre> <pre> *** * </pre> <hr> <foreign name="answers" url="^Answers::c:s0p36"> </page> <page pagename="Exercise 2.59"> Exercise 2.59 Modify the program you wrote in <a href="^Exercises::c:s0p80"><img src="bckgrnds/icons/exercise.gif" align=sidebar>Exercise 2.58</a> to read an odd number in the range 1 to 19 to specify the number of rows in the diamond. Your program should then display a diamond of the appropriate size. </page> <page pagename="Exercise 2.60"> Exercise 2.60 A criticism of the break statement and the continue statement is that each is unstructured. Actually break statements and continue statements can always be replaced by structured statements, although doing so can be awkward. Describe in general how you would remove any break statement from a loop in a program and replace that statement with some structured equivalent. (Hint: The break statement leaves a loop from within the body of the loop. The other way to leave is by failing the loop-continuation test. Consider using in the loop- continuation test a second test that indicates "early exit because of a 'break' condition.") Use the technique you developed here to remove the break statement from the program of <a href="^Code::c:s0p10"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.26</a>. <foreign name="answers" url="^Answers::c:s0p37"> </page> <page pagename="Exercise 2.61"> Exercise 2.61 What does the following program segment do? <pre> for ( i = 1; i <= 5; i++ ) { for ( j = 1; j <= 3; j++ ) { for ( k = 1; k <= 4; k++ ) cout << '*'; cout << endl; } cout << endl; } </pre> </page> <page pagename="Exercise 2.62"> Exercise 2.62 Describe in general how you would remove any continue statement from a loop in a program and replace that statement with some structured equivalent. Use the technique you developed here to remove the continue statement from the program of <a href="^Code::c:s0p11"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.27</a>. </page> <page pagename="Exercise 2.63"> Exercise 2.63 ("The Twelve Days of Christmas" Song) Write a program that uses repetition and switch structures to print the song "The Twelve Days of Christmas." One switch structure should be used to print the day (i.e., "First," "Second," etc.). A separate switch structure should be used to print the remainder of each verse. <foreign name="answers" url="^Answers::c:s0p38"> </page> <page pagename="Exercise 2.64"> Exercise 2.64 Exercise 2.64 corresponds to<a href="#s22p0"> Section 2.22</a>, "Thinking About Objects." Describe in 200 words or less what an automobile is and does. List the nouns and verbs separately. In the text, we stated that each noun may correspond to an object that will need to be built to implement a system, in this case a car. Pick five of the objects you listed and for each list several attributes and several behaviors. Describe briefly how these objects interact with one another and other objects in your description. You have just performed several of the key steps in a typical object-oriented design. </page> <page pagename="Exercise 2.65"> Exercise 2.65 (Peter Minuet Problem) Legend has it that in 1626 Peter Minuet purchased Manhattan for $24.00 in barter. Did he make a good investment? To answer this question, modify the compound interest program of<a href="^Code::c:s0p7"> <img src="bckgrnds/icons/code_ico.gif" align=sidebar>Fig. 2.21</a> to begin with a principal of $24.00 and to calculate the amount of interest on deposit if that money had been kept on deposit until this year (372 years through 1998). Run the program with interest rates of 5%, 6%, 7%, 8%, 9% and 10% to observe the wonders of compound interest. </page> </section> <section type=Popup name=Errors title="Common Errors"> <page> Using a keyword as an identifier is a syntax error. </page> <page> Forgetting one or both of the braces that delimit a compound statement can lead to syntax errors or logic errors in a program. </page> <page> Placing a semicolon after the condition in an if structure leads to a logic error in single- selection if structures and a syntax error in double-selection if structures (if the if-part contains an actual body statement). </page> <page> Spelling the keyword while with an uppercase W as in While (remember that C++ is a case-sensitive language) is a syntax error. All of C++'s reserved keywords such as while, if, and else </page> <page> contain only lowercase letters. </page> <page> Not providing in the body of a while structure an action that eventually causes the condition in the while to become false normally results in an error called an "infinite loop" in which the </page> <page> repetition structure never terminates. </page> <page> If a counter or total is not initialized, the results of your program will probably be incorrect. This is an example of a logic error. </page> <page> In a counter-controlled loop, because the loop counter (when counting up by one each time through the loop) is one higher than its last legitimate value (i.e., 11 in the case of counting from 1 to 10), using the counter value </page> <page> in a calculation after the loop is often an off-by- one-error. </page> <page> Choosing a sentinel value that is also a legitimate data value is a logic error. </page> <page> An attempt to divide by zero causes a fatal error. </page> <page> Using floating-point numbers in a manner that assumes they are represented precisely can lead to incorrect results. Floating-point numbers are represented only approximately by most computers. </page> <page> Attempting to use the increment or decrement operator on an expression other than a simple variable name, e.g., writing ++(x + 1) is a syntax error. </page> <page> Because floating-point values may be approximate, controlling counting loops with floating- point variables may result in imprecise counter values and inaccurate tests for termination. </page> <page> Using an incorrect relational operator or using an incorrect final value of a loop counter in the condition of a while or for structure can cause off-by-one errors. </page> <page> When the control variable of a for structure is initially defined in the initialization section of the for structure header, using the control </page> <page> variable after the body of the structure is a syntax error. </page> <page> Placing a semicolon immediately to the right of the right parenthesis of a for header makes the body of that for structure an empty statement. This is normally a logic error. </page> <page> Using commas instead of the two required semicolons in a for header is a syntax error. </page> <page> Not using the proper relational operator in the loop-continuation condition of a loop that counts downwards (such as incorrectly using i <= 1 in a loop counting down to 1) is usually a logic error that will yield incorrect </page> <page> results when the program runs. </page> <page> Forgetting to include the math.h file in a program that uses math library functions is a syntax error. </page> <page> Omitting the space between the word case and the integral value being tested in a switch structure can cause a logic error. For example, writing case3: instead of writing case 3: simply creates an unused label </page> <page> (we will say more about this in Chapter 18). The problem is that the switch structure will not perform the appropriate actions when the switch's controlling expression has a value of 3. </page> <page> Forgetting a break statement when one is needed in a switch structure is a logic error. </page> <page> Not processing newline and other whitespace characters in the input when reading characters one at a time can cause logic errors. </page> <page> Providing identical case labels in a switch structure is a syntax error. </page> <page> Infinite loops are caused when the loop- continuation condition in a while, for, or do/ while structure never becomes false. To prevent this, make sure the value of the condition does change somewhere in the </page> <page> header or body of the loop so the condition can eventually become false. </page> <page> Although 3 < x < 7 is a mathematically correct condition, it does not evaluate correctly in C++. Use <tt>(</tt> 3 < x && x < 7 <tt>)</tt> to get the proper evaluation in C++. </page> <page> In expressions using operator &&, it is possible that a condition--we will call this the dependent condition--may require another condition to be true for it to be meaningful to evaluate the dependent </page> <page> condition. In this case, the dependent condition should be placed after the other condition or an error might occur. </page> <page> Using operator == for assignment, or using operator = for equality, are logic errors. </page> </section> <section type=Popup name=Engineer title="Engineering"> <page> Any C++ program we will ever build can be constructed from only seven different types of control structures (if, if/ else, switch, while, do/ while and for) combined in only two ways (control-structure </page> <page> stacking and control structure nesting). </page> <page> A compound statement can be placed anywhere in a program that a single statement can be placed. </page> <page> Just as a compound statement can be placed anywhere a single statement can be placed, it is also possible to have no statement at all, i.e., the empty statement. The empty statement is represented by placing </page> <page> a semicolon (;) where a statement would normally be. </page> <page> Many programs can be divided logically into three phases: an initialization phase that initializes the program variables; a processing phase that inputs data values and adjusts program variables accordingly; and a </page> <page> termination phase that calculates and prints the final results. </page> <page> Each refinement, as well as the top itself, is a complete specification of the algorithm; only the level of detail varies. </page> <page> The programmer terminates the top- down, stepwise refinement process when the pseudocode algorithm is specified in sufficient detail for the programmer to be able to convert the pseudocode to C++. </page> <page> Implementing the C++ program is then normally straightforward. </page> <page> Experience has shown that the most difficult part of solving a problem on a computer is developing the algorithm for the solution. Once a correct algorithm has been specified, the process of producing a working </page> <page> C++ program from the algorithm is normally straightforward. </page> <page> Many experienced programmers write programs without ever using program development tools like pseudocode. These programmers feel that their ultimate goal is to solve the problem on a computer, and that </page> <page> writing pseudocode merely delays the production of final outputs. Although this may work for simple and familiar problems, it can lead to serious errors and delays on large, complex projects. </page> <page> Placing a semicolon immediately after a for header is sometimes used to create a so- called delay loop. Such a for loop with an empty body still loops the indicated number of times doing nothing other than the counting. </page> <page> You might use a delay loop, for example, to slow down a program that is producing outputs on the screen too quickly for you to read them. </page> <page> There is a tension between achieving quality software engineering and achieving the best performing software. Often, one of these goals is achieved at the expense of the other. </page> </section> <section type=Popup name=AppletPopup title="Applet Examples"> <page> This chapter does not contain any Applet Examples. </page> </section> </chapter> </html> </html>